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\DBAL\Connection;
11. use Doctrine\DBAL\LockMode;
12. use Doctrine\DBAL\Platforms\AbstractPlatform;
13. use Doctrine\DBAL\Result;
14. use Doctrine\DBAL\Types\Type;
15. use Doctrine\DBAL\Types\Types;
16. use Doctrine\Deprecations\Deprecation;
17. use Doctrine\ORM\EntityManagerInterface;
18. use Doctrine\ORM\Internal\CriteriaOrderings;
19. use Doctrine\ORM\Mapping\ClassMetadata;
20. use Doctrine\ORM\Mapping\MappingException;
21. use Doctrine\ORM\Mapping\QuoteStrategy;
22. use Doctrine\ORM\OptimisticLockException;
23. use Doctrine\ORM\PersistentCollection;
24. use Doctrine\ORM\Persisters\Exception\CantUseInOperatorOnCompositeKeys;
25. use Doctrine\ORM\Persisters\Exception\InvalidOrientation;
26. use Doctrine\ORM\Persisters\Exception\UnrecognizedField;
27. use Doctrine\ORM\Persisters\SqlExpressionVisitor;
28. use Doctrine\ORM\Persisters\SqlValueVisitor;
29. use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
30. use Doctrine\ORM\Query;
31. use Doctrine\ORM\Query\QueryException;
32. use Doctrine\ORM\Repository\Exception\InvalidFindByCall;
33. use Doctrine\ORM\UnitOfWork;
34. use Doctrine\ORM\Utility\IdentifierFlattener;
35. use Doctrine\ORM\Utility\LockSqlHelper;
36. use Doctrine\ORM\Utility\PersisterHelper;
37. use LengthException;
39. use function array_combine;
40. use function array_keys;
41. use function array_map;
42. use function array_merge;
43. use function array_search;
44. use function array_unique;
45. use function array_values;
46. use function assert;
47. use function count;
48. use function implode;
49. use function is_array;
50. use function is_object;
51. use function reset;
52. use function spl_object_id;
53. use function sprintf;
54. use function str_contains;
55. use function strtoupper;
56. use function trim;
58. /**
59.  * A BasicEntityPersister maps an entity to a single table in a relational database.
60.  *
61.  * A persister is always responsible for a single entity type.
62.  *
63.  * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
64.  * state of entities onto a relational database when the UnitOfWork is committed,
65.  * as well as for basic querying of entities and their associations (not DQL).
66.  *
67.  * The persisting operations that are invoked during a commit of a UnitOfWork to
68.  * persist the persistent entity state are:
69.  *
70.  *   - {@link addInsert} : To schedule an entity for insertion.
71.  *   - {@link executeInserts} : To execute all scheduled insertions.
72.  *   - {@link update} : To update the persistent state of an entity.
73.  *   - {@link delete} : To delete the persistent state of an entity.
74.  *
75.  * As can be seen from the above list, insertions are batched and executed all at once
76.  * for increased efficiency.
77.  *
78.  * The querying operations invoked during a UnitOfWork, either through direct find
79.  * requests or lazy-loading, are the following:
80.  *
81.  *   - {@link load} : Loads (the state of) a single, managed entity.
82.  *   - {@link loadAll} : Loads multiple, managed entities.
83.  *   - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
84.  *   - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
85.  *   - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
86.  *
87.  * The BasicEntityPersister implementation provides the default behavior for
88.  * persisting and querying entities that are mapped to a single database table.
89.  *
90.  * Subclasses can be created to provide custom persisting and querying strategies,
91.  * i.e. spanning multiple tables.
92.  *
93.  * @psalm-import-type AssociationMapping from ClassMetadata
94.  */
95. class BasicEntityPersister implements EntityPersister
96. {
97.     use CriteriaOrderings;
98.     use LockSqlHelper;
100.     /** @var array<string,string> */
101.     private static $comparisonMap = [
102.         Comparison::EQ          => '= %s',
103.         Comparison::NEQ         => '!= %s',
104.         Comparison::GT          => '> %s',
105.         Comparison::GTE         => '>= %s',
106.         Comparison::LT          => '< %s',
107.         Comparison::LTE         => '<= %s',
108.         Comparison::IN          => 'IN (%s)',
109.         Comparison::NIN         => 'NOT IN (%s)',
110.         Comparison::CONTAINS    => 'LIKE %s',
111.         Comparison::STARTS_WITH => 'LIKE %s',
112.         Comparison::ENDS_WITH   => 'LIKE %s',
113.     ];
115.     /**
116.      * Metadata object that describes the mapping of the mapped entity class.
117.      *
118.      * @var ClassMetadata
119.      */
120.     protected $class;
122.     /**
123.      * The underlying DBAL Connection of the used EntityManager.
124.      *
125.      * @var Connection $conn
126.      */
127.     protected $conn;
129.     /**
130.      * The database platform.
131.      *
132.      * @var AbstractPlatform
133.      */
134.     protected $platform;
136.     /**
137.      * The EntityManager instance.
138.      *
139.      * @var EntityManagerInterface
140.      */
141.     protected $em;
143.     /**
144.      * Queued inserts.
145.      *
146.      * @psalm-var array<int, object>
147.      */
148.     protected $queuedInserts = [];
150.     /**
151.      * The map of column names to DBAL mapping types of all prepared columns used
152.      * when INSERTing or UPDATEing an entity.
153.      *
154.      * @see prepareInsertData($entity)
155.      * @see prepareUpdateData($entity)
156.      *
157.      * @var mixed[]
158.      */
159.     protected $columnTypes = [];
161.     /**
162.      * The map of quoted column names.
163.      *
164.      * @see prepareInsertData($entity)
165.      * @see prepareUpdateData($entity)
166.      *
167.      * @var mixed[]
168.      */
169.     protected $quotedColumns = [];
171.     /**
172.      * The INSERT SQL statement used for entities handled by this persister.
173.      * This SQL is only generated once per request, if at all.
174.      *
175.      * @var string|null
176.      */
177.     private $insertSql;
179.     /**
180.      * The quote strategy.
181.      *
182.      * @var QuoteStrategy
183.      */
184.     protected $quoteStrategy;
186.     /**
187.      * The IdentifierFlattener used for manipulating identifiers
188.      *
189.      * @var IdentifierFlattener
190.      */
191.     protected $identifierFlattener;
193.     /** @var CachedPersisterContext */
194.     protected $currentPersisterContext;
196.     /** @var CachedPersisterContext */
197.     private $limitsHandlingContext;
199.     /** @var CachedPersisterContext */
200.     private $noLimitsContext;
202.     /**
203.      * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
204.      * and persists instances of the class described by the given ClassMetadata descriptor.
205.      */
206.     public function __construct(EntityManagerInterface $em, ClassMetadata $class)
207.     {
208.         $this->em                    = $em;
209.         $this->class                 = $class;
210.         $this->conn                  = $em->getConnection();
211.         $this->platform              = $this->conn->getDatabasePlatform();
212.         $this->quoteStrategy         = $em->getConfiguration()->getQuoteStrategy();
213.         $this->identifierFlattener   = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
214.         $this->noLimitsContext       = $this->currentPersisterContext = new CachedPersisterContext(
215.             $class,
216.             new Query\ResultSetMapping(),
217.             false
218.         );
219.         $this->limitsHandlingContext = new CachedPersisterContext(
220.             $class,
221.             new Query\ResultSetMapping(),
222.             true
223.         );
224.     }
226.     /**
227.      * {@inheritDoc}
228.      */
229.     public function getClassMetadata()
230.     {
231.         return $this->class;
232.     }
234.     /**
235.      * {@inheritDoc}
236.      */
237.     public function getResultSetMapping()
238.     {
239.         return $this->currentPersisterContext->rsm;
240.     }
242.     /**
243.      * {@inheritDoc}
244.      */
245.     public function addInsert($entity)
246.     {
247.         $this->queuedInserts[spl_object_id($entity)] = $entity;
248.     }
250.     /**
251.      * {@inheritDoc}
252.      */
253.     public function getInserts()
254.     {
255.         return $this->queuedInserts;
256.     }
258.     /**
259.      * {@inheritDoc}
260.      */
261.     public function executeInserts()
262.     {
263.         if (! $this->queuedInserts) {
264.             return;
265.         }
267.         $uow            = $this->em->getUnitOfWork();
268.         $idGenerator    = $this->class->idGenerator;
269.         $isPostInsertId = $idGenerator->isPostInsertGenerator();
271.         $stmt      = $this->conn->prepare($this->getInsertSQL());
272.         $tableName = $this->class->getTableName();
274.         foreach ($this->queuedInserts as $key => $entity) {
275.             $insertData = $this->prepareInsertData($entity);
277.             if (isset($insertData[$tableName])) {
278.                 $paramIndex = 1;
280.                 foreach ($insertData[$tableName] as $column => $value) {
281.                     $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$column]);
282.                 }
283.             }
285.             $stmt->executeStatement();
287.             if ($isPostInsertId) {
288.                 $generatedId = $idGenerator->generateId($this->em, $entity);
289.                 $id          = [$this->class->identifier[0] => $generatedId];
291.                 $uow->assignPostInsertId($entity, $generatedId);
292.             } else {
293.                 $id = $this->class->getIdentifierValues($entity);
294.             }
296.             if ($this->class->requiresFetchAfterChange) {
297.                 $this->assignDefaultVersionAndUpsertableValues($entity, $id);
298.             }
300.             // Unset this queued insert, so that the prepareUpdateData() method knows right away
301.             // (for the next entity already) that the current entity has been written to the database
302.             // and no extra updates need to be scheduled to refer to it.
303.             //
304.             // In \Doctrine\ORM\UnitOfWork::executeInserts(), the UoW already removed entities
305.             // from its own list (\Doctrine\ORM\UnitOfWork::$entityInsertions) right after they
306.             // were given to our addInsert() method.
307.             unset($this->queuedInserts[$key]);
308.         }
309.     }
311.     /**
312.      * Retrieves the default version value which was created
313.      * by the preceding INSERT statement and assigns it back in to the
314.      * entities version field if the given entity is versioned.
315.      * Also retrieves values of columns marked as 'non insertable' and / or
316.      * 'not updatable' and assigns them back to the entities corresponding fields.
317.      *
318.      * @param object  $entity
319.      * @param mixed[] $id
320.      *
321.      * @return void
322.      */
323.     protected function assignDefaultVersionAndUpsertableValues($entity, array $id)
324.     {
325.         $values = $this->fetchVersionAndNotUpsertableValues($this->class, $id);
327.         foreach ($values as $field => $value) {
328.             $value = Type::getType($this->class->fieldMappings[$field]['type'])->convertToPHPValue($value, $this->platform);
330.             $this->class->setFieldValue($entity, $field, $value);
331.         }
332.     }
334.     /**
335.      * Fetches the current version value of a versioned entity and / or the values of fields
336.      * marked as 'not insertable' and / or 'not updatable'.
337.      *
338.      * @param ClassMetadata $versionedClass
339.      * @param mixed[]       $id
340.      *
341.      * @return mixed
342.      */
343.     protected function fetchVersionAndNotUpsertableValues($versionedClass, array $id)
344.     {
345.         $columnNames = [];
346.         foreach ($this->class->fieldMappings as $key => $column) {
347.             if (isset($column['generated']) || ($this->class->isVersioned && $key === $versionedClass->versionField)) {
348.                 $columnNames[$key] = $this->quoteStrategy->getColumnName($key, $versionedClass, $this->platform);
349.             }
350.         }
352.         $tableName  = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
353.         $identifier = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
355.         // FIXME: Order with composite keys might not be correct
356.         $sql = 'SELECT ' . implode(', ', $columnNames)
357.             . ' FROM ' . $tableName
358.             . ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
360.         $flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
362.         $values = $this->conn->fetchNumeric(
363.             $sql,
364.             array_values($flatId),
365.             $this->extractIdentifierTypes($id, $versionedClass)
366.         );
368.         if ($values === false) {
369.             throw new LengthException('Unexpected empty result for database query.');
370.         }
372.         $values = array_combine(array_keys($columnNames), $values);
374.         if (! $values) {
375.             throw new LengthException('Unexpected number of database columns.');
376.         }
378.         return $values;
379.     }
381.     /**
382.      * @param mixed[] $id
383.      *
384.      * @return int[]|null[]|string[]
385.      * @psalm-return list<int|string|null>
386.      */
387.     final protected function extractIdentifierTypes(array $id, ClassMetadata $versionedClass): array
388.     {
389.         $types = [];
391.         foreach ($id as $field => $value) {
392.             $types = array_merge($types, $this->getTypes($field, $value, $versionedClass));
393.         }
395.         return $types;
396.     }
398.     /**
399.      * {@inheritDoc}
400.      */
401.     public function update($entity)
402.     {
403.         $tableName  = $this->class->getTableName();
404.         $updateData = $this->prepareUpdateData($entity);
406.         if (! isset($updateData[$tableName])) {
407.             return;
408.         }
410.         $data = $updateData[$tableName];
412.         if (! $data) {
413.             return;
414.         }
416.         $isVersioned     = $this->class->isVersioned;
417.         $quotedTableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
419.         $this->updateTable($entity, $quotedTableName, $data, $isVersioned);
421.         if ($this->class->requiresFetchAfterChange) {
422.             $id = $this->class->getIdentifierValues($entity);
424.             $this->assignDefaultVersionAndUpsertableValues($entity, $id);
425.         }
426.     }
428.     /**
429.      * Performs an UPDATE statement for an entity on a specific table.
430.      * The UPDATE can optionally be versioned, which requires the entity to have a version field.
431.      *
432.      * @param object  $entity          The entity object being updated.
433.      * @param string  $quotedTableName The quoted name of the table to apply the UPDATE on.
434.      * @param mixed[] $updateData      The map of columns to update (column => value).
435.      * @param bool    $versioned       Whether the UPDATE should be versioned.
436.      *
437.      * @throws UnrecognizedField
438.      * @throws OptimisticLockException
439.      */
440.     final protected function updateTable(
441.         $entity,
442.         $quotedTableName,
443.         array $updateData,
444.         $versioned = false
445.     ): void {
446.         $set    = [];
447.         $types  = [];
448.         $params = [];
450.         foreach ($updateData as $columnName => $value) {
451.             $placeholder = '?';
452.             $column      = $columnName;
454.             switch (true) {
455.                 case isset($this->class->fieldNames[$columnName]):
456.                     $fieldName = $this->class->fieldNames[$columnName];
457.                     $column    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
459.                     if (isset($this->class->fieldMappings[$fieldName]['requireSQLConversion'])) {
460.                         $type        = Type::getType($this->columnTypes[$columnName]);
461.                         $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
462.                     }
464.                     break;
466.                 case isset($this->quotedColumns[$columnName]):
467.                     $column = $this->quotedColumns[$columnName];
469.                     break;
470.             }
472.             $params[] = $value;
473.             $set[]    = $column . ' = ' . $placeholder;
474.             $types[]  = $this->columnTypes[$columnName];
475.         }
477.         $where      = [];
478.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
480.         foreach ($this->class->identifier as $idField) {
481.             if (! isset($this->class->associationMappings[$idField])) {
482.                 $params[] = $identifier[$idField];
483.                 $types[]  = $this->class->fieldMappings[$idField]['type'];
484.                 $where[]  = $this->quoteStrategy->getColumnName($idField, $this->class, $this->platform);
486.                 continue;
487.             }
489.             $params[] = $identifier[$idField];
490.             $where[]  = $this->quoteStrategy->getJoinColumnName(
491.                 $this->class->associationMappings[$idField]['joinColumns'][0],
492.                 $this->class,
493.                 $this->platform
494.             );
496.             $targetMapping = $this->em->getClassMetadata($this->class->associationMappings[$idField]['targetEntity']);
497.             $targetType    = PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping, $this->em);
499.             if ($targetType === []) {
500.                 throw UnrecognizedField::byFullyQualifiedName($this->class->name, $targetMapping->identifier[0]);
501.             }
503.             $types[] = reset($targetType);
504.         }
506.         if ($versioned) {
507.             $versionField = $this->class->versionField;
508.             assert($versionField !== null);
509.             $versionFieldType = $this->class->fieldMappings[$versionField]['type'];
510.             $versionColumn    = $this->quoteStrategy->getColumnName($versionField, $this->class, $this->platform);
512.             $where[]  = $versionColumn;
513.             $types[]  = $this->class->fieldMappings[$versionField]['type'];
514.             $params[] = $this->class->reflFields[$versionField]->getValue($entity);
516.             switch ($versionFieldType) {
517.                 case Types::SMALLINT:
518.                 case Types::INTEGER:
519.                 case Types::BIGINT:
520.                     $set[] = $versionColumn . ' = ' . $versionColumn . ' + 1';
521.                     break;
523.                 case Types::DATETIME_MUTABLE:
524.                     $set[] = $versionColumn . ' = CURRENT_TIMESTAMP';
525.                     break;
526.             }
527.         }
529.         $sql = 'UPDATE ' . $quotedTableName
530.              . ' SET ' . implode(', ', $set)
531.              . ' WHERE ' . implode(' = ? AND ', $where) . ' = ?';
533.         $result = $this->conn->executeStatement($sql, $params, $types);
535.         if ($versioned && ! $result) {
536.             throw OptimisticLockException::lockFailed($entity);
537.         }
538.     }
540.     /**
541.      * @param array<mixed> $identifier
542.      * @param string[]     $types
543.      *
544.      * @todo Add check for platform if it supports foreign keys/cascading.
545.      */
546.     protected function deleteJoinTableRecords(array $identifier, array $types): void
547.     {
548.         foreach ($this->class->associationMappings as $mapping) {
549.             if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY || isset($mapping['isOnDeleteCascade'])) {
550.                 continue;
551.             }
553.             // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
554.             // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
555.             $selfReferential = ($mapping['targetEntity'] === $mapping['sourceEntity']);
556.             $class           = $this->class;
557.             $association     = $mapping;
558.             $otherColumns    = [];
559.             $otherKeys       = [];
560.             $keys            = [];
562.             if (! $mapping['isOwningSide']) {
563.                 $class       = $this->em->getClassMetadata($mapping['targetEntity']);
564.                 $association = $class->associationMappings[$mapping['mappedBy']];
565.             }
567.             $joinColumns = $mapping['isOwningSide']
568.                 ? $association['joinTable']['joinColumns']
569.                 : $association['joinTable']['inverseJoinColumns'];
571.             if ($selfReferential) {
572.                 $otherColumns = ! $mapping['isOwningSide']
573.                     ? $association['joinTable']['joinColumns']
574.                     : $association['joinTable']['inverseJoinColumns'];
575.             }
577.             foreach ($joinColumns as $joinColumn) {
578.                 $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
579.             }
581.             foreach ($otherColumns as $joinColumn) {
582.                 $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
583.             }
585.             $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
587.             $this->conn->delete($joinTableName, array_combine($keys, $identifier), $types);
589.             if ($selfReferential) {
590.                 $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier), $types);
591.             }
592.         }
593.     }
595.     /**
596.      * {@inheritDoc}
597.      */
598.     public function delete($entity)
599.     {
600.         $class      = $this->class;
601.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
602.         $tableName  = $this->quoteStrategy->getTableName($class, $this->platform);
603.         $idColumns  = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform);
604.         $id         = array_combine($idColumns, $identifier);
605.         $types      = $this->getClassIdentifiersTypes($class);
607.         $this->deleteJoinTableRecords($identifier, $types);
609.         return (bool) $this->conn->delete($tableName, $id, $types);
610.     }
612.     /**
613.      * Prepares the changeset of an entity for database insertion (UPDATE).
614.      *
615.      * The changeset is obtained from the currently running UnitOfWork.
616.      *
617.      * During this preparation the array that is passed as the second parameter is filled with
618.      * <columnName> => <value> pairs, grouped by table name.
619.      *
620.      * Example:
621.      * <code>
622.      * array(
623.      *    'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
624.      *    'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
625.      *    ...
626.      * )
627.      * </code>
628.      *
629.      * @param object $entity   The entity for which to prepare the data.
630.      * @param bool   $isInsert Whether the data to be prepared refers to an insert statement.
631.      *
632.      * @return mixed[][] The prepared data.
633.      * @psalm-return array<string, array<array-key, mixed|null>>
634.      */
635.     protected function prepareUpdateData($entity, bool $isInsert = false)
636.     {
637.         $versionField = null;
638.         $result       = [];
639.         $uow          = $this->em->getUnitOfWork();
641.         $versioned = $this->class->isVersioned;
642.         if ($versioned !== false) {
643.             $versionField = $this->class->versionField;
644.         }
646.         foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
647.             if (isset($versionField) && $versionField === $field) {
648.                 continue;
649.             }
651.             if (isset($this->class->embeddedClasses[$field])) {
652.                 continue;
653.             }
655.             $newVal = $change[1];
657.             if (! isset($this->class->associationMappings[$field])) {
658.                 $fieldMapping = $this->class->fieldMappings[$field];
659.                 $columnName   = $fieldMapping['columnName'];
661.                 if (! $isInsert && isset($fieldMapping['notUpdatable'])) {
662.                     continue;
663.                 }
665.                 if ($isInsert && isset($fieldMapping['notInsertable'])) {
666.                     continue;
667.                 }
669.                 $this->columnTypes[$columnName] = $fieldMapping['type'];
671.                 $result[$this->getOwningTable($field)][$columnName] = $newVal;
673.                 continue;
674.             }
676.             $assoc = $this->class->associationMappings[$field];
678.             // Only owning side of x-1 associations can have a FK column.
679.             if (! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
680.                 continue;
681.             }
683.             if ($newVal !== null) {
684.                 $oid = spl_object_id($newVal);
686.                 // If the associated entity $newVal is not yet persisted and/or does not yet have
687.                 // an ID assigned, we must set $newVal = null. This will insert a null value and
688.                 // schedule an extra update on the UnitOfWork.
689.                 //
690.                 // This gives us extra time to a) possibly obtain a database-generated identifier
691.                 // value for $newVal, and b) insert $newVal into the database before the foreign
692.                 // key reference is being made.
693.                 //
694.                 // When looking at $this->queuedInserts and $uow->isScheduledForInsert, be aware
695.                 // of the implementation details that our own executeInserts() method will remove
696.                 // entities from the former as soon as the insert statement has been executed and
697.                 // a post-insert ID has been assigned (if necessary), and that the UnitOfWork has
698.                 // already removed entities from its own list at the time they were passed to our
699.                 // addInsert() method.
700.                 //
701.                 // Then, there is one extra exception we can make: An entity that references back to itself
702.                 // _and_ uses an application-provided ID (the "NONE" generator strategy) also does not
703.                 // need the extra update, although it is still in the list of insertions itself.
704.                 // This looks like a minor optimization at first, but is the capstone for being able to
705.                 // use non-NULLable, self-referencing associations in applications that provide IDs (like UUIDs).
706.                 if (
707.                     (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal))
708.                     && ! ($newVal === $entity && $this->class->isIdentifierNatural())
709.                 ) {
710.                     $uow->scheduleExtraUpdate($entity, [$field => [null, $newVal]]);
712.                     $newVal = null;
713.                 }
714.             }
716.             $newValId = null;
718.             if ($newVal !== null) {
719.                 $newValId = $uow->getEntityIdentifier($newVal);
720.             }
722.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
723.             $owningTable = $this->getOwningTable($field);
725.             foreach ($assoc['joinColumns'] as $joinColumn) {
726.                 $sourceColumn = $joinColumn['name'];
727.                 $targetColumn = $joinColumn['referencedColumnName'];
728.                 $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
730.                 $this->quotedColumns[$sourceColumn]  = $quotedColumn;
731.                 $this->columnTypes[$sourceColumn]    = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
732.                 $result[$owningTable][$sourceColumn] = $newValId
733.                     ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
734.                     : null;
735.             }
736.         }
738.         return $result;
739.     }
741.     /**
742.      * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
743.      * The changeset of the entity is obtained from the currently running UnitOfWork.
744.      *
745.      * The default insert data preparation is the same as for updates.
746.      *
747.      * @see prepareUpdateData
748.      *
749.      * @param object $entity The entity for which to prepare the data.
750.      *
751.      * @return mixed[][] The prepared data for the tables to update.
752.      * @psalm-return array<string, mixed[]>
753.      */
754.     protected function prepareInsertData($entity)
755.     {
756.         return $this->prepareUpdateData($entity, true);
757.     }
759.     /**
760.      * {@inheritDoc}
761.      */
762.     public function getOwningTable($fieldName)
763.     {
764.         return $this->class->getTableName();
765.     }
767.     /**
768.      * {@inheritDoc}
769.      */
770.     public function load(array $criteria, $entity = null, $assoc = null, array $hints = [], $lockMode = null, $limit = null, ?array $orderBy = null)
771.     {
772.         $this->switchPersisterContext(null, $limit);
774.         $sql              = $this->getSelectSQL($criteria, $assoc, $lockMode, $limit, null, $orderBy);
775.         [$params, $types] = $this->expandParameters($criteria);
776.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
778.         if ($entity !== null) {
779.             $hints[Query::HINT_REFRESH]        = true;
780.             $hints[Query::HINT_REFRESH_ENTITY] = $entity;
781.         }
783.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
784.         $entities = $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, $hints);
786.         return $entities ? $entities[0] : null;
787.     }
789.     /**
790.      * {@inheritDoc}
791.      */
792.     public function loadById(array $identifier, $entity = null)
793.     {
794.         return $this->load($identifier, $entity);
795.     }
797.     /**
798.      * {@inheritDoc}
799.      */
800.     public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
801.     {
802.         $foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc['targetEntity']);
803.         if ($foundEntity !== false) {
804.             return $foundEntity;
805.         }
807.         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
809.         if ($assoc['isOwningSide']) {
810.             $isInverseSingleValued = $assoc['inversedBy'] && ! $targetClass->isCollectionValuedAssociation($assoc['inversedBy']);
812.             // Mark inverse side as fetched in the hints, otherwise the UoW would
813.             // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
814.             $hints = [];
816.             if ($isInverseSingleValued) {
817.                 $hints['fetched']['r'][$assoc['inversedBy']] = true;
818.             }
820.             $targetEntity = $this->load($identifier, null, $assoc, $hints);
822.             // Complete bidirectional association, if necessary
823.             if ($targetEntity !== null && $isInverseSingleValued) {
824.                 $targetClass->reflFields[$assoc['inversedBy']]->setValue($targetEntity, $sourceEntity);
825.             }
827.             return $targetEntity;
828.         }
830.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
831.         $owningAssoc = $targetClass->getAssociationMapping($assoc['mappedBy']);
833.         $computedIdentifier = [];
835.         // TRICKY: since the association is specular source and target are flipped
836.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
837.             if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
838.                 throw MappingException::joinColumnMustPointToMappedField(
839.                     $sourceClass->name,
840.                     $sourceKeyColumn
841.                 );
842.             }
844.             $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
845.                 $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
846.         }
848.         $targetEntity = $this->load($computedIdentifier, null, $assoc);
850.         if ($targetEntity !== null) {
851.             $targetClass->setFieldValue($targetEntity, $assoc['mappedBy'], $sourceEntity);
852.         }
854.         return $targetEntity;
855.     }
857.     /**
858.      * {@inheritDoc}
859.      */
860.     public function refresh(array $id, $entity, $lockMode = null)
861.     {
862.         $sql              = $this->getSelectSQL($id, null, $lockMode);
863.         [$params, $types] = $this->expandParameters($id);
864.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
866.         $hydrator = $this->em->newHydrator(Query::HYDRATE_OBJECT);
867.         $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
868.     }
870.     /**
871.      * {@inheritDoc}
872.      */
873.     public function count($criteria = [])
874.     {
875.         $sql = $this->getCountSQL($criteria);
877.         [$params, $types] = $criteria instanceof Criteria
878.             ? $this->expandCriteriaParameters($criteria)
879.             : $this->expandParameters($criteria);
881.         return (int) $this->conn->executeQuery($sql, $params, $types)->fetchOne();
882.     }
884.     /**
885.      * {@inheritDoc}
886.      */
887.     public function loadCriteria(Criteria $criteria)
888.     {
889.         $orderBy = self::getCriteriaOrderings($criteria);
890.         $limit   = $criteria->getMaxResults();
891.         $offset  = $criteria->getFirstResult();
892.         $query   = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
894.         [$params, $types] = $this->expandCriteriaParameters($criteria);
896.         $stmt     = $this->conn->executeQuery($query, $params, $types);
897.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
899.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
900.     }
902.     /**
903.      * {@inheritDoc}
904.      */
905.     public function expandCriteriaParameters(Criteria $criteria)
906.     {
907.         $expression = $criteria->getWhereExpression();
908.         $sqlParams  = [];
909.         $sqlTypes   = [];
911.         if ($expression === null) {
912.             return [$sqlParams, $sqlTypes];
913.         }
915.         $valueVisitor = new SqlValueVisitor();
917.         $valueVisitor->dispatch($expression);
919.         [, $types] = $valueVisitor->getParamsAndTypes();
921.         foreach ($types as $type) {
922.             [$field, $value, $operator] = $type;
924.             if ($value === null && ($operator === Comparison::EQ || $operator === Comparison::NEQ)) {
925.                 continue;
926.             }
928.             $sqlParams = array_merge($sqlParams, $this->getValues($value));
929.             $sqlTypes  = array_merge($sqlTypes, $this->getTypes($field, $value, $this->class));
930.         }
932.         return [$sqlParams, $sqlTypes];
933.     }
935.     /**
936.      * {@inheritDoc}
937.      */
938.     public function loadAll(array $criteria = [], ?array $orderBy = null, $limit = null, $offset = null)
939.     {
940.         $this->switchPersisterContext($offset, $limit);
942.         $sql              = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
943.         [$params, $types] = $this->expandParameters($criteria);
944.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
946.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
948.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
949.     }
951.     /**
952.      * {@inheritDoc}
953.      */
954.     public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
955.     {
956.         $this->switchPersisterContext($offset, $limit);
958.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity, $offset, $limit);
960.         return $this->loadArrayFromResult($assoc, $stmt);
961.     }
963.     /**
964.      * Loads an array of entities from a given DBAL statement.
965.      *
966.      * @param mixed[] $assoc
967.      *
968.      * @return mixed[]
969.      */
970.     private function loadArrayFromResult(array $assoc, Result $stmt): array
971.     {
972.         $rsm   = $this->currentPersisterContext->rsm;
973.         $hints = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
975.         if (isset($assoc['indexBy'])) {
976.             $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
977.             $rsm->addIndexBy('r', $assoc['indexBy']);
978.         }
980.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
981.     }
983.     /**
984.      * Hydrates a collection from a given DBAL statement.
985.      *
986.      * @param mixed[] $assoc
987.      *
988.      * @return mixed[]
989.      */
990.     private function loadCollectionFromStatement(
991.         array $assoc,
992.         Result $stmt,
993.         PersistentCollection $coll
994.     ): array {
995.         $rsm   = $this->currentPersisterContext->rsm;
996.         $hints = [
997.             UnitOfWork::HINT_DEFEREAGERLOAD => true,
998.             'collection' => $coll,
999.         ];
1001.         if (isset($assoc['indexBy'])) {
1002.             $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
1003.             $rsm->addIndexBy('r', $assoc['indexBy']);
1004.         }
1006.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
1007.     }
1009.     /**
1010.      * {@inheritDoc}
1011.      */
1012.     public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
1013.     {
1014.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity);
1016.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
1017.     }
1019.     /**
1020.      * @param object $sourceEntity
1021.      * @psalm-param array<string, mixed> $assoc
1022.      *
1023.      * @return Result
1024.      *
1025.      * @throws MappingException
1026.      */
1027.     private function getManyToManyStatement(
1028.         array $assoc,
1029.         $sourceEntity,
1030.         ?int $offset = null,
1031.         ?int $limit = null
1032.     ) {
1033.         $this->switchPersisterContext($offset, $limit);
1035.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
1036.         $class       = $sourceClass;
1037.         $association = $assoc;
1038.         $criteria    = [];
1039.         $parameters  = [];
1041.         if (! $assoc['isOwningSide']) {
1042.             $class       = $this->em->getClassMetadata($assoc['targetEntity']);
1043.             $association = $class->associationMappings[$assoc['mappedBy']];
1044.         }
1046.         $joinColumns = $assoc['isOwningSide']
1047.             ? $association['joinTable']['joinColumns']
1048.             : $association['joinTable']['inverseJoinColumns'];
1050.         $quotedJoinTable = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
1052.         foreach ($joinColumns as $joinColumn) {
1053.             $sourceKeyColumn = $joinColumn['referencedColumnName'];
1054.             $quotedKeyColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
1056.             switch (true) {
1057.                 case $sourceClass->containsForeignIdentifier:
1058.                     $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
1059.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
1061.                     if (isset($sourceClass->associationMappings[$field])) {
1062.                         $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
1063.                         $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
1064.                     }
1066.                     break;
1068.                 case isset($sourceClass->fieldNames[$sourceKeyColumn]):
1069.                     $field = $sourceClass->fieldNames[$sourceKeyColumn];
1070.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
1072.                     break;
1074.                 default:
1075.                     throw MappingException::joinColumnMustPointToMappedField(
1076.                         $sourceClass->name,
1077.                         $sourceKeyColumn
1078.                     );
1079.             }
1081.             $criteria[$quotedJoinTable . '.' . $quotedKeyColumn] = $value;
1082.             $parameters[]                                        = [
1083.                 'value' => $value,
1084.                 'field' => $field,
1085.                 'class' => $sourceClass,
1086.             ];
1087.         }
1089.         $sql              = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
1090.         [$params, $types] = $this->expandToManyParameters($parameters);
1092.         return $this->conn->executeQuery($sql, $params, $types);
1093.     }
1095.     /**
1096.      * {@inheritDoc}
1097.      */
1098.     public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, ?array $orderBy = null)
1099.     {
1100.         $this->switchPersisterContext($offset, $limit);
1102.         $lockSql    = '';
1103.         $joinSql    = '';
1104.         $orderBySql = '';
1106.         if ($assoc !== null && $assoc['type'] === ClassMetadata::MANY_TO_MANY) {
1107.             $joinSql = $this->getSelectManyToManyJoinSQL($assoc);
1108.         }
1110.         if (isset($assoc['orderBy'])) {
1111.             $orderBy = $assoc['orderBy'];
1112.         }
1114.         if ($orderBy) {
1115.             $orderBySql = $this->getOrderBySQL($orderBy, $this->getSQLTableAlias($this->class->name));
1116.         }
1118.         $conditionSql = $criteria instanceof Criteria
1119.             ? $this->getSelectConditionCriteriaSQL($criteria)
1120.             : $this->getSelectConditionSQL($criteria, $assoc);
1122.         switch ($lockMode) {
1123.             case LockMode::PESSIMISTIC_READ:
1124.                 $lockSql = ' ' . $this->getReadLockSQL($this->platform);
1125.                 break;
1127.             case LockMode::PESSIMISTIC_WRITE:
1128.                 $lockSql = ' ' . $this->getWriteLockSQL($this->platform);
1129.                 break;
1130.         }
1132.         $columnList = $this->getSelectColumnsSQL();
1133.         $tableAlias = $this->getSQLTableAlias($this->class->name);
1134.         $filterSql  = $this->generateFilterConditionSQL($this->class, $tableAlias);
1135.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
1137.         if ($filterSql !== '') {
1138.             $conditionSql = $conditionSql
1139.                 ? $conditionSql . ' AND ' . $filterSql
1140.                 : $filterSql;
1141.         }
1143.         $select = 'SELECT ' . $columnList;
1144.         $from   = ' FROM ' . $tableName . ' ' . $tableAlias;
1145.         $join   = $this->currentPersisterContext->selectJoinSql . $joinSql;
1146.         $where  = ($conditionSql ? ' WHERE ' . $conditionSql : '');
1147.         $lock   = $this->platform->appendLockHint($from, $lockMode ?? LockMode::NONE);
1148.         $query  = $select
1149.             . $lock
1150.             . $join
1151.             . $where
1152.             . $orderBySql;
1154.         return $this->platform->modifyLimitQuery($query, $limit, $offset ?? 0) . $lockSql;
1155.     }
1157.     /**
1158.      * {@inheritDoc}
1159.      */
1160.     public function getCountSQL($criteria = [])
1161.     {
1162.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
1163.         $tableAlias = $this->getSQLTableAlias($this->class->name);
1165.         $conditionSql = $criteria instanceof Criteria
1166.             ? $this->getSelectConditionCriteriaSQL($criteria)
1167.             : $this->getSelectConditionSQL($criteria);
1169.         $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
1171.         if ($filterSql !== '') {
1172.             $conditionSql = $conditionSql
1173.                 ? $conditionSql . ' AND ' . $filterSql
1174.                 : $filterSql;
1175.         }
1177.         return 'SELECT COUNT(*) '
1178.             . 'FROM ' . $tableName . ' ' . $tableAlias
1179.             . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
1180.     }
1182.     /**
1183.      * Gets the ORDER BY SQL snippet for ordered collections.
1184.      *
1185.      * @psalm-param array<string, string> $orderBy
1186.      *
1187.      * @throws InvalidOrientation
1188.      * @throws InvalidFindByCall
1189.      * @throws UnrecognizedField
1190.      */
1191.     final protected function getOrderBySQL(array $orderBy, string $baseTableAlias): string
1192.     {
1193.         $orderByList = [];
1195.         foreach ($orderBy as $fieldName => $orientation) {
1196.             $orientation = strtoupper(trim($orientation));
1198.             if ($orientation !== 'ASC' && $orientation !== 'DESC') {
1199.                 throw InvalidOrientation::fromClassNameAndField($this->class->name, $fieldName);
1200.             }
1202.             if (isset($this->class->fieldMappings[$fieldName])) {
1203.                 $tableAlias = isset($this->class->fieldMappings[$fieldName]['inherited'])
1204.                     ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
1205.                     : $baseTableAlias;
1207.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
1208.                 $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
1210.                 continue;
1211.             }
1213.             if (isset($this->class->associationMappings[$fieldName])) {
1214.                 if (! $this->class->associationMappings[$fieldName]['isOwningSide']) {
1215.                     throw InvalidFindByCall::fromInverseSideUsage($this->class->name, $fieldName);
1216.                 }
1218.                 $tableAlias = isset($this->class->associationMappings[$fieldName]['inherited'])
1219.                     ? $this->getSQLTableAlias($this->class->associationMappings[$fieldName]['inherited'])
1220.                     : $baseTableAlias;
1222.                 foreach ($this->class->associationMappings[$fieldName]['joinColumns'] as $joinColumn) {
1223.                     $columnName    = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
1224.                     $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
1225.                 }
1227.                 continue;
1228.             }
1230.             throw UnrecognizedField::byFullyQualifiedName($this->class->name, $fieldName);
1231.         }
1233.         return ' ORDER BY ' . implode(', ', $orderByList);
1234.     }
1236.     /**
1237.      * Gets the SQL fragment with the list of columns to select when querying for
1238.      * an entity in this persister.
1239.      *
1240.      * Subclasses should override this method to alter or change the select column
1241.      * list SQL fragment. Note that in the implementation of BasicEntityPersister
1242.      * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
1243.      * Subclasses may or may not do the same.
1244.      *
1245.      * @return string The SQL fragment.
1246.      */
1247.     protected function getSelectColumnsSQL()
1248.     {
1249.         if ($this->currentPersisterContext->selectColumnListSql !== null) {
1250.             return $this->currentPersisterContext->selectColumnListSql;
1251.         }
1253.         $columnList = [];
1254.         $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r'); // r for root
1256.         // Add regular columns to select list
1257.         foreach ($this->class->fieldNames as $field) {
1258.             $columnList[] = $this->getSelectColumnSQL($field, $this->class);
1259.         }
1261.         $this->currentPersisterContext->selectJoinSql = '';
1262.         $eagerAliasCounter                            = 0;
1264.         foreach ($this->class->associationMappings as $assocField => $assoc) {
1265.             $assocColumnSQL = $this->getSelectColumnAssociationSQL($assocField, $assoc, $this->class);
1267.             if ($assocColumnSQL) {
1268.                 $columnList[] = $assocColumnSQL;
1269.             }
1271.             $isAssocToOneInverseSide = $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
1272.             $isAssocFromOneEager     = $assoc['type'] & ClassMetadata::TO_ONE && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
1274.             if (! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
1275.                 continue;
1276.             }
1278.             if ((($assoc['type'] & ClassMetadata::TO_MANY) > 0) && $this->currentPersisterContext->handlesLimits) {
1279.                 continue;
1280.             }
1282.             $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
1284.             if ($eagerEntity->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
1285.                 continue; // now this is why you shouldn't use inheritance
1286.             }
1288.             $assocAlias = 'e' . ($eagerAliasCounter++);
1289.             $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc['targetEntity'], $assocAlias, 'r', $assocField);
1291.             foreach ($eagerEntity->fieldNames as $field) {
1292.                 $columnList[] = $this->getSelectColumnSQL($field, $eagerEntity, $assocAlias);
1293.             }
1295.             foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
1296.                 $eagerAssocColumnSQL = $this->getSelectColumnAssociationSQL(
1297.                     $eagerAssocField,
1298.                     $eagerAssoc,
1299.                     $eagerEntity,
1300.                     $assocAlias
1301.                 );
1303.                 if ($eagerAssocColumnSQL) {
1304.                     $columnList[] = $eagerAssocColumnSQL;
1305.                 }
1306.             }
1308.             $association   = $assoc;
1309.             $joinCondition = [];
1311.             if (isset($assoc['indexBy'])) {
1312.                 $this->currentPersisterContext->rsm->addIndexBy($assocAlias, $assoc['indexBy']);
1313.             }
1315.             if (! $assoc['isOwningSide']) {
1316.                 $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
1317.                 $association = $eagerEntity->getAssociationMapping($assoc['mappedBy']);
1318.             }
1320.             $joinTableAlias = $this->getSQLTableAlias($eagerEntity->name, $assocAlias);
1321.             $joinTableName  = $this->quoteStrategy->getTableName($eagerEntity, $this->platform);
1323.             if ($assoc['isOwningSide']) {
1324.                 $tableAlias                                    = $this->getSQLTableAlias($association['targetEntity'], $assocAlias);
1325.                 $this->currentPersisterContext->selectJoinSql .= ' ' . $this->getJoinSQLForJoinColumns($association['joinColumns']);
1327.                 foreach ($association['joinColumns'] as $joinColumn) {
1328.                     $sourceCol       = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
1329.                     $targetCol       = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
1330.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'])
1331.                                         . '.' . $sourceCol . ' = ' . $tableAlias . '.' . $targetCol;
1332.                 }
1334.                 // Add filter SQL
1335.                 $filterSql = $this->generateFilterConditionSQL($eagerEntity, $tableAlias);
1336.                 if ($filterSql) {
1337.                     $joinCondition[] = $filterSql;
1338.                 }
1339.             } else {
1340.                 $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
1342.                 foreach ($association['joinColumns'] as $joinColumn) {
1343.                     $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
1344.                     $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
1346.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'], $assocAlias) . '.' . $sourceCol . ' = '
1347.                         . $this->getSQLTableAlias($association['targetEntity']) . '.' . $targetCol;
1348.                 }
1349.             }
1351.             $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';
1352.             $this->currentPersisterContext->selectJoinSql .= implode(' AND ', $joinCondition);
1353.         }
1355.         $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
1357.         return $this->currentPersisterContext->selectColumnListSql;
1358.     }
1360.     /**
1361.      * Gets the SQL join fragment used when selecting entities from an association.
1362.      *
1363.      * @param string             $field
1364.      * @param AssociationMapping $assoc
1365.      * @param string             $alias
1366.      *
1367.      * @return string
1368.      */
1369.     protected function getSelectColumnAssociationSQL($field, $assoc, ClassMetadata $class, $alias = 'r')
1370.     {
1371.         if (! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)) {
1372.             return '';
1373.         }
1375.         $columnList    = [];
1376.         $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
1377.         $isIdentifier  = isset($assoc['id']) && $assoc['id'] === true;
1378.         $sqlTableAlias = $this->getSQLTableAlias($class->name, ($alias === 'r' ? '' : $alias));
1380.         foreach ($assoc['joinColumns'] as $joinColumn) {
1381.             $quotedColumn     = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
1382.             $resultColumnName = $this->getSQLColumnAlias($joinColumn['name']);
1383.             $type             = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
1385.             $this->currentPersisterContext->rsm->addMetaResult($alias, $resultColumnName, $joinColumn['name'], $isIdentifier, $type);
1387.             $columnList[] = sprintf('%s.%s AS %s', $sqlTableAlias, $quotedColumn, $resultColumnName);
1388.         }
1390.         return implode(', ', $columnList);
1391.     }
1393.     /**
1394.      * Gets the SQL join fragment used when selecting entities from a
1395.      * many-to-many association.
1396.      *
1397.      * @psalm-param AssociationMapping $manyToMany
1398.      *
1399.      * @return string
1400.      */
1401.     protected function getSelectManyToManyJoinSQL(array $manyToMany)
1402.     {
1403.         $conditions       = [];
1404.         $association      = $manyToMany;
1405.         $sourceTableAlias = $this->getSQLTableAlias($this->class->name);
1407.         if (! $manyToMany['isOwningSide']) {
1408.             $targetEntity = $this->em->getClassMetadata($manyToMany['targetEntity']);
1409.             $association  = $targetEntity->associationMappings[$manyToMany['mappedBy']];
1410.         }
1412.         $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
1413.         $joinColumns   = $manyToMany['isOwningSide']
1414.             ? $association['joinTable']['inverseJoinColumns']
1415.             : $association['joinTable']['joinColumns'];
1417.         foreach ($joinColumns as $joinColumn) {
1418.             $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
1419.             $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
1420.             $conditions[]       = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableName . '.' . $quotedSourceColumn;
1421.         }
1423.         return ' INNER JOIN ' . $joinTableName . ' ON ' . implode(' AND ', $conditions);
1424.     }
1426.     /**
1427.      * {@inheritDoc}
1428.      */
1429.     public function getInsertSQL()
1430.     {
1431.         if ($this->insertSql !== null) {
1432.             return $this->insertSql;
1433.         }
1435.         $columns   = $this->getInsertColumnList();
1436.         $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
1438.         if (empty($columns)) {
1439.             $identityColumn  = $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class, $this->platform);
1440.             $this->insertSql = $this->platform->getEmptyIdentityInsertSQL($tableName, $identityColumn);
1442.             return $this->insertSql;
1443.         }
1445.         $values  = [];
1446.         $columns = array_unique($columns);
1448.         foreach ($columns as $column) {
1449.             $placeholder = '?';
1451.             if (
1452.                 isset($this->class->fieldNames[$column])
1453.                 && isset($this->columnTypes[$this->class->fieldNames[$column]])
1454.                 && isset($this->class->fieldMappings[$this->class->fieldNames[$column]]['requireSQLConversion'])
1455.             ) {
1456.                 $type        = Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
1457.                 $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
1458.             }
1460.             $values[] = $placeholder;
1461.         }
1463.         $columns = implode(', ', $columns);
1464.         $values  = implode(', ', $values);
1466.         $this->insertSql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tableName, $columns, $values);
1468.         return $this->insertSql;
1469.     }
1471.     /**
1472.      * Gets the list of columns to put in the INSERT SQL statement.
1473.      *
1474.      * Subclasses should override this method to alter or change the list of
1475.      * columns placed in the INSERT statements used by the persister.
1476.      *
1477.      * @return string[] The list of columns.
1478.      * @psalm-return list<string>
1479.      */
1480.     protected function getInsertColumnList()
1481.     {
1482.         $columns = [];
1484.         foreach ($this->class->reflFields as $name => $field) {
1485.             if ($this->class->isVersioned && $this->class->versionField === $name) {
1486.                 continue;
1487.             }
1489.             if (isset($this->class->embeddedClasses[$name])) {
1490.                 continue;
1491.             }
1493.             if (isset($this->class->associationMappings[$name])) {
1494.                 $assoc = $this->class->associationMappings[$name];
1496.                 if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
1497.                     foreach ($assoc['joinColumns'] as $joinColumn) {
1498.                         $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
1499.                     }
1500.                 }
1502.                 continue;
1503.             }
1505.             if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] !== $name) {
1506.                 if (isset($this->class->fieldMappings[$name]['notInsertable'])) {
1507.                     continue;
1508.                 }
1510.                 $columns[]                = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
1511.                 $this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
1512.             }
1513.         }
1515.         return $columns;
1516.     }
1518.     /**
1519.      * Gets the SQL snippet of a qualified column name for the given field name.
1520.      *
1521.      * @param string        $field The field name.
1522.      * @param ClassMetadata $class The class that declares this field. The table this class is
1523.      *                             mapped to must own the column for the given field.
1524.      * @param string        $alias
1525.      *
1526.      * @return string
1527.      */
1528.     protected function getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r')
1529.     {
1530.         $root         = $alias === 'r' ? '' : $alias;
1531.         $tableAlias   = $this->getSQLTableAlias($class->name, $root);
1532.         $fieldMapping = $class->fieldMappings[$field];
1533.         $sql          = sprintf('%s.%s', $tableAlias, $this->quoteStrategy->getColumnName($field, $class, $this->platform));
1534.         $columnAlias  = $this->getSQLColumnAlias($fieldMapping['columnName']);
1536.         $this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field);
1537.         if (! empty($fieldMapping['enumType'])) {
1538.             $this->currentPersisterContext->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
1539.         }
1541.         if (isset($fieldMapping['requireSQLConversion'])) {
1542.             $type = Type::getType($fieldMapping['type']);
1543.             $sql  = $type->convertToPHPValueSQL($sql, $this->platform);
1544.         }
1546.         return $sql . ' AS ' . $columnAlias;
1547.     }
1549.     /**
1550.      * Gets the SQL table alias for the given class name.
1551.      *
1552.      * @param string $className
1553.      * @param string $assocName
1554.      *
1555.      * @return string The SQL table alias.
1556.      *
1557.      * @todo Reconsider. Binding table aliases to class names is not such a good idea.
1558.      */
1559.     protected function getSQLTableAlias($className, $assocName = '')
1560.     {
1561.         if ($assocName) {
1562.             $className .= '#' . $assocName;
1563.         }
1565.         if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
1566.             return $this->currentPersisterContext->sqlTableAliases[$className];
1567.         }
1569.         $tableAlias = 't' . $this->currentPersisterContext->sqlAliasCounter++;
1571.         $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
1573.         return $tableAlias;
1574.     }
1576.     /**
1577.      * {@inheritDoc}
1578.      */
1579.     public function lock(array $criteria, $lockMode)
1580.     {
1581.         $lockSql      = '';
1582.         $conditionSql = $this->getSelectConditionSQL($criteria);
1584.         switch ($lockMode) {
1585.             case LockMode::PESSIMISTIC_READ:
1586.                 $lockSql = $this->getReadLockSQL($this->platform);
1588.                 break;
1589.             case LockMode::PESSIMISTIC_WRITE:
1590.                 $lockSql = $this->getWriteLockSQL($this->platform);
1591.                 break;
1592.         }
1594.         $lock  = $this->getLockTablesSql($lockMode);
1595.         $where = ($conditionSql ? ' WHERE ' . $conditionSql : '') . ' ';
1596.         $sql   = 'SELECT 1 '
1597.              . $lock
1598.              . $where
1599.              . $lockSql;
1601.         [$params, $types] = $this->expandParameters($criteria);
1603.         $this->conn->executeQuery($sql, $params, $types);
1604.     }
1606.     /**
1607.      * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
1608.      *
1609.      * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants.
1610.      * @psalm-param LockMode::*|null $lockMode
1611.      *
1612.      * @return string
1613.      */
1614.     protected function getLockTablesSql($lockMode)
1615.     {
1616.         if ($lockMode === null) {
1617.             Deprecation::trigger(
1618.                 'doctrine/orm',
1619.                 'https://github.com/doctrine/orm/pull/9466',
1620.                 'Passing null as argument to %s is deprecated, pass LockMode::NONE instead.',
1621.                 __METHOD__
1622.             );
1624.             $lockMode = LockMode::NONE;
1625.         }
1627.         return $this->platform->appendLockHint(
1628.             'FROM '
1629.             . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
1630.             . $this->getSQLTableAlias($this->class->name),
1631.             $lockMode
1632.         );
1633.     }
1635.     /**
1636.      * Gets the Select Where Condition from a Criteria object.
1637.      *
1638.      * @return string
1639.      */
1640.     protected function getSelectConditionCriteriaSQL(Criteria $criteria)
1641.     {
1642.         $expression = $criteria->getWhereExpression();
1644.         if ($expression === null) {
1645.             return '';
1646.         }
1648.         $visitor = new SqlExpressionVisitor($this, $this->class);
1650.         return $visitor->dispatch($expression);
1651.     }
1653.     /**
1654.      * {@inheritDoc}
1655.      */
1656.     public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
1657.     {
1658.         $selectedColumns = [];
1659.         $columns         = $this->getSelectConditionStatementColumnSQL($field, $assoc);
1661.         if (count($columns) > 1 && $comparison === Comparison::IN) {
1662.             /*
1663.              *  @todo try to support multi-column IN expressions.
1664.              *  Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
1665.              */
1666.             throw CantUseInOperatorOnCompositeKeys::create();
1667.         }
1669.         foreach ($columns as $column) {
1670.             $placeholder = '?';
1672.             if (isset($this->class->fieldMappings[$field]['requireSQLConversion'])) {
1673.                 $type        = Type::getType($this->class->fieldMappings[$field]['type']);
1674.                 $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->platform);
1675.             }
1677.             if ($comparison !== null) {
1678.                 // special case null value handling
1679.                 if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && $value === null) {
1680.                     $selectedColumns[] = $column . ' IS NULL';
1682.                     continue;
1683.                 }
1685.                 if ($comparison === Comparison::NEQ && $value === null) {
1686.                     $selectedColumns[] = $column . ' IS NOT NULL';
1688.                     continue;
1689.                 }
1691.                 $selectedColumns[] = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
1693.                 continue;
1694.             }
1696.             if (is_array($value)) {
1697.                 $in = sprintf('%s IN (%s)', $column, $placeholder);
1699.                 if (array_search(null, $value, true) !== false) {
1700.                     $selectedColumns[] = sprintf('(%s OR %s IS NULL)', $in, $column);
1702.                     continue;
1703.                 }
1705.                 $selectedColumns[] = $in;
1707.                 continue;
1708.             }
1710.             if ($value === null) {
1711.                 $selectedColumns[] = sprintf('%s IS NULL', $column);
1713.                 continue;
1714.             }
1716.             $selectedColumns[] = sprintf('%s = %s', $column, $placeholder);
1717.         }
1719.         return implode(' AND ', $selectedColumns);
1720.     }
1722.     /**
1723.      * Builds the left-hand-side of a where condition statement.
1724.      *
1725.      * @psalm-param AssociationMapping|null $assoc
1726.      *
1727.      * @return string[]
1728.      * @psalm-return list<string>
1729.      *
1730.      * @throws InvalidFindByCall
1731.      * @throws UnrecognizedField
1732.      */
1733.     private function getSelectConditionStatementColumnSQL(
1734.         string $field,
1735.         ?array $assoc = null
1736.     ): array {
1737.         if (isset($this->class->fieldMappings[$field])) {
1738.             $className = $this->class->fieldMappings[$field]['inherited'] ?? $this->class->name;
1740.             return [$this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getColumnName($field, $this->class, $this->platform)];
1741.         }
1743.         if (isset($this->class->associationMappings[$field])) {
1744.             $association = $this->class->associationMappings[$field];
1745.             // Many-To-Many requires join table check for joinColumn
1746.             $columns = [];
1747.             $class   = $this->class;
1749.             if ($association['type'] === ClassMetadata::MANY_TO_MANY) {
1750.                 if (! $association['isOwningSide']) {
1751.                     $association = $assoc;
1752.                 }
1754.                 $joinTableName = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
1755.                 $joinColumns   = $assoc['isOwningSide']
1756.                     ? $association['joinTable']['joinColumns']
1757.                     : $association['joinTable']['inverseJoinColumns'];
1759.                 foreach ($joinColumns as $joinColumn) {
1760.                     $columns[] = $joinTableName . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
1761.                 }
1762.             } else {
1763.                 if (! $association['isOwningSide']) {
1764.                     throw InvalidFindByCall::fromInverseSideUsage(
1765.                         $this->class->name,
1766.                         $field
1767.                     );
1768.                 }
1770.                 $className = $association['inherited'] ?? $this->class->name;
1772.                 foreach ($association['joinColumns'] as $joinColumn) {
1773.                     $columns[] = $this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
1774.                 }
1775.             }
1777.             return $columns;
1778.         }
1780.         if ($assoc !== null && ! str_contains($field, ' ') && ! str_contains($field, '(')) {
1781.             // very careless developers could potentially open up this normally hidden api for userland attacks,
1782.             // therefore checking for spaces and function calls which are not allowed.
1784.             // found a join column condition, not really a "field"
1785.             return [$field];
1786.         }
1788.         throw UnrecognizedField::byFullyQualifiedName($this->class->name, $field);
1789.     }
1791.     /**
1792.      * Gets the conditional SQL fragment used in the WHERE clause when selecting
1793.      * entities in this persister.
1794.      *
1795.      * Subclasses are supposed to override this method if they intend to change
1796.      * or alter the criteria by which entities are selected.
1797.      *
1798.      * @param AssociationMapping|null $assoc
1799.      * @psalm-param array<string, mixed> $criteria
1800.      * @psalm-param array<string, mixed>|null $assoc
1801.      *
1802.      * @return string
1803.      */
1804.     protected function getSelectConditionSQL(array $criteria, $assoc = null)
1805.     {
1806.         $conditions = [];
1808.         foreach ($criteria as $field => $value) {
1809.             $conditions[] = $this->getSelectConditionStatementSQL($field, $value, $assoc);
1810.         }
1812.         return implode(' AND ', $conditions);
1813.     }
1815.     /**
1816.      * {@inheritDoc}
1817.      */
1818.     public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
1819.     {
1820.         $this->switchPersisterContext($offset, $limit);
1822.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity, $offset, $limit);
1824.         return $this->loadArrayFromResult($assoc, $stmt);
1825.     }
1827.     /**
1828.      * {@inheritDoc}
1829.      */
1830.     public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
1831.     {
1832.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity);
1834.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
1835.     }
1837.     /**
1838.      * Builds criteria and execute SQL statement to fetch the one to many entities from.
1839.      *
1840.      * @param object $sourceEntity
1841.      * @psalm-param AssociationMapping $assoc
1842.      */
1843.     private function getOneToManyStatement(
1844.         array $assoc,
1845.         $sourceEntity,
1846.         ?int $offset = null,
1847.         ?int $limit = null
1848.     ): Result {
1849.         $this->switchPersisterContext($offset, $limit);
1851.         $criteria    = [];
1852.         $parameters  = [];
1853.         $owningAssoc = $this->class->associationMappings[$assoc['mappedBy']];
1854.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
1855.         $tableAlias  = $this->getSQLTableAlias($owningAssoc['inherited'] ?? $this->class->name);
1857.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
1858.             if ($sourceClass->containsForeignIdentifier) {
1859.                 $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
1860.                 $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
1862.                 if (isset($sourceClass->associationMappings[$field])) {
1863.                     $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
1864.                     $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
1865.                 }
1867.                 $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
1868.                 $parameters[]                                   = [
1869.                     'value' => $value,
1870.                     'field' => $field,
1871.                     'class' => $sourceClass,
1872.                 ];
1874.                 continue;
1875.             }
1877.             $field = $sourceClass->fieldNames[$sourceKeyColumn];
1878.             $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
1880.             $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
1881.             $parameters[]                                   = [
1882.                 'value' => $value,
1883.                 'field' => $field,
1884.                 'class' => $sourceClass,
1885.             ];
1886.         }
1888.         $sql              = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
1889.         [$params, $types] = $this->expandToManyParameters($parameters);
1891.         return $this->conn->executeQuery($sql, $params, $types);
1892.     }
1894.     /**
1895.      * {@inheritDoc}
1896.      */
1897.     public function expandParameters($criteria)
1898.     {
1899.         $params = [];
1900.         $types  = [];
1902.         foreach ($criteria as $field => $value) {
1903.             if ($value === null) {
1904.                 continue; // skip null values.
1905.             }
1907.             $types  = array_merge($types, $this->getTypes($field, $value, $this->class));
1908.             $params = array_merge($params, $this->getValues($value));
1909.         }
1911.         return [$params, $types];
1912.     }
1914.     /**
1915.      * Expands the parameters from the given criteria and use the correct binding types if found,
1916.      * specialized for OneToMany or ManyToMany associations.
1917.      *
1918.      * @param mixed[][] $criteria an array of arrays containing following:
1919.      *                             - field to which each criterion will be bound
1920.      *                             - value to be bound
1921.      *                             - class to which the field belongs to
1922.      *
1923.      * @return mixed[][]
1924.      * @psalm-return array{0: array, 1: list<int|string|null>}
1925.      */
1926.     private function expandToManyParameters(array $criteria): array
1927.     {
1928.         $params = [];
1929.         $types  = [];
1931.         foreach ($criteria as $criterion) {
1932.             if ($criterion['value'] === null) {
1933.                 continue; // skip null values.
1934.             }
1936.             $types  = array_merge($types, $this->getTypes($criterion['field'], $criterion['value'], $criterion['class']));
1937.             $params = array_merge($params, $this->getValues($criterion['value']));
1938.         }
1940.         return [$params, $types];
1941.     }
1943.     /**
1944.      * Infers field types to be used by parameter type casting.
1945.      *
1946.      * @param mixed $value
1947.      *
1948.      * @return int[]|null[]|string[]
1949.      * @psalm-return list<int|string|null>
1950.      *
1951.      * @throws QueryException
1952.      */
1953.     private function getTypes(string $field, $value, ClassMetadata $class): array
1954.     {
1955.         $types = [];
1957.         switch (true) {
1958.             case isset($class->fieldMappings[$field]):
1959.                 $types = array_merge($types, [$class->fieldMappings[$field]['type']]);
1960.                 break;
1962.             case isset($class->associationMappings[$field]):
1963.                 $assoc = $class->associationMappings[$field];
1964.                 $class = $this->em->getClassMetadata($assoc['targetEntity']);
1966.                 if (! $assoc['isOwningSide']) {
1967.                     $assoc = $class->associationMappings[$assoc['mappedBy']];
1968.                     $class = $this->em->getClassMetadata($assoc['targetEntity']);
1969.                 }
1971.                 $columns = $assoc['type'] === ClassMetadata::MANY_TO_MANY
1972.                     ? $assoc['relationToTargetKeyColumns']
1973.                     : $assoc['sourceToTargetKeyColumns'];
1975.                 foreach ($columns as $column) {
1976.                     $types[] = PersisterHelper::getTypeOfColumn($column, $class, $this->em);
1977.                 }
1979.                 break;
1981.             default:
1982.                 $types[] = null;
1983.                 break;
1984.         }
1986.         if (is_array($value)) {
1987.             return array_map(static function ($type) {
1988.                 $type = Type::getType($type);
1990.                 return $type->getBindingType() + Connection::ARRAY_PARAM_OFFSET;
1991.             }, $types);
1992.         }
1994.         return $types;
1995.     }
1997.     /**
1998.      * Retrieves the parameters that identifies a value.
1999.      *
2000.      * @param mixed $value
2001.      *
2002.      * @return mixed[]
2003.      */
2004.     private function getValues($value): array
2005.     {
2006.         if (is_array($value)) {
2007.             $newValue = [];
2009.             foreach ($value as $itemValue) {
2010.                 $newValue = array_merge($newValue, $this->getValues($itemValue));
2011.             }
2013.             return [$newValue];
2014.         }
2016.         return $this->getIndividualValue($value);
2017.     }
2019.     /**
2020.      * Retrieves an individual parameter value.
2021.      *
2022.      * @param mixed $value
2023.      *
2024.      * @psalm-return list<mixed>
2025.      */
2026.     private function getIndividualValue($value): array
2027.     {
2028.         if (! is_object($value)) {
2029.             return [$value];
2030.         }
2032.         if ($value instanceof BackedEnum) {
2033.             return [$value->value];
2034.         }
2036.         $valueClass = DefaultProxyClassNameResolver::getClass($value);
2038.         if ($this->em->getMetadataFactory()->isTransient($valueClass)) {
2039.             return [$value];
2040.         }
2042.         $class = $this->em->getClassMetadata($valueClass);
2044.         if ($class->isIdentifierComposite) {
2045.             $newValue = [];
2047.             foreach ($class->getIdentifierValues($value) as $innerValue) {
2048.                 $newValue = array_merge($newValue, $this->getValues($innerValue));
2049.             }
2051.             return $newValue;
2052.         }
2054.         return [$this->em->getUnitOfWork()->getSingleIdentifierValue($value)];
2055.     }
2057.     /**
2058.      * {@inheritDoc}
2059.      */
2060.     public function exists($entity, ?Criteria $extraConditions = null)
2061.     {
2062.         $criteria = $this->class->getIdentifierValues($entity);
2064.         if (! $criteria) {
2065.             return false;
2066.         }
2068.         $alias = $this->getSQLTableAlias($this->class->name);
2070.         $sql = 'SELECT 1 '
2071.              . $this->getLockTablesSql(LockMode::NONE)
2072.              . ' WHERE ' . $this->getSelectConditionSQL($criteria);
2074.         [$params, $types] = $this->expandParameters($criteria);
2076.         if ($extraConditions !== null) {
2077.             $sql                             .= ' AND ' . $this->getSelectConditionCriteriaSQL($extraConditions);
2078.             [$criteriaParams, $criteriaTypes] = $this->expandCriteriaParameters($extraConditions);
2080.             $params = array_merge($params, $criteriaParams);
2081.             $types  = array_merge($types, $criteriaTypes);
2082.         }
2084.         $filterSql = $this->generateFilterConditionSQL($this->class, $alias);
2085.         if ($filterSql) {
2086.             $sql .= ' AND ' . $filterSql;
2087.         }
2089.         return (bool) $this->conn->fetchOne($sql, $params, $types);
2090.     }
2092.     /**
2093.      * Generates the appropriate join SQL for the given join column.
2094.      *
2095.      * @param array[] $joinColumns The join columns definition of an association.
2096.      * @psalm-param array<array<string, mixed>> $joinColumns
2097.      *
2098.      * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
2099.      */
2100.     protected function getJoinSQLForJoinColumns($joinColumns)
2101.     {
2102.         // if one of the join columns is nullable, return left join
2103.         foreach ($joinColumns as $joinColumn) {
2104.             if (! isset($joinColumn['nullable']) || $joinColumn['nullable']) {
2105.                 return 'LEFT JOIN';
2106.             }
2107.         }
2109.         return 'INNER JOIN';
2110.     }
2112.     /**
2113.      * @param string $columnName
2114.      *
2115.      * @return string
2116.      */
2117.     public function getSQLColumnAlias($columnName)
2118.     {
2119.         return $this->quoteStrategy->getColumnAlias($columnName, $this->currentPersisterContext->sqlAliasCounter++, $this->platform);
2120.     }
2122.     /**
2123.      * Generates the filter SQL for a given entity and table alias.
2124.      *
2125.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
2126.      * @param string        $targetTableAlias The table alias of the joined/selected table.
2127.      *
2128.      * @return string The SQL query part to add to a query.
2129.      */
2130.     protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
2131.     {
2132.         $filterClauses = [];
2134.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
2135.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
2136.             if ($filterExpr !== '') {
2137.                 $filterClauses[] = '(' . $filterExpr . ')';
2138.             }
2139.         }
2141.         $sql = implode(' AND ', $filterClauses);
2143.         return $sql ? '(' . $sql . ')' : ''; // Wrap again to avoid "X or Y and FilterConditionSQL"
2144.     }
2146.     /**
2147.      * Switches persister context according to current query offset/limits
2148.      *
2149.      * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
2150.      *
2151.      * @param int|null $offset
2152.      * @param int|null $limit
2153.      *
2154.      * @return void
2155.      */
2156.     protected function switchPersisterContext($offset, $limit)
2157.     {
2158.         if ($offset === null && $limit === null) {
2159.             $this->currentPersisterContext = $this->noLimitsContext;
2161.             return;
2162.         }
2164.         $this->currentPersisterContext = $this->limitsHandlingContext;
2165.     }
2167.     /**
2168.      * @return string[]
2169.      * @psalm-return list<string>
2170.      */
2171.     protected function getClassIdentifiersTypes(ClassMetadata $class): array
2172.     {
2173.         $entityManager = $this->em;
2175.         return array_map(
2176.             static function ($fieldName) use ($class, $entityManager): string {
2177.                 $types = PersisterHelper::getTypeOfField($fieldName, $class, $entityManager);
2178.                 assert(isset($types[0]));
2180.                 return $types[0];
2181.             },
2182.             $class->identifier
2183.         );
2184.     }
2185. }