vendor/doctrine/orm/lib/Doctrine/ORM/Persisters/Entity/BasicEntityPersister.php line 1237

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\Util\ClassUtils;
  11. use Doctrine\DBAL\Connection;
  12. use Doctrine\DBAL\LockMode;
  13. use Doctrine\DBAL\Platforms\AbstractPlatform;
  14. use Doctrine\DBAL\Result;
  15. use Doctrine\DBAL\Types\Type;
  16. use Doctrine\DBAL\Types\Types;
  17. use Doctrine\Deprecations\Deprecation;
  18. use Doctrine\ORM\EntityManagerInterface;
  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\Query;
  30. use Doctrine\ORM\Query\QueryException;
  31. use Doctrine\ORM\Repository\Exception\InvalidFindByCall;
  32. use Doctrine\ORM\UnitOfWork;
  33. use Doctrine\ORM\Utility\IdentifierFlattener;
  34. use Doctrine\ORM\Utility\PersisterHelper;
  35. use LengthException;
  37. use function array_combine;
  38. use function array_keys;
  39. use function array_map;
  40. use function array_merge;
  41. use function array_search;
  42. use function array_unique;
  43. use function array_values;
  44. use function assert;
  45. use function count;
  46. use function implode;
  47. use function is_array;
  48. use function is_object;
  49. use function reset;
  50. use function spl_object_id;
  51. use function sprintf;
  52. use function str_contains;
  53. use function strtoupper;
  54. use function trim;
  56. /**
  57.  * A BasicEntityPersister maps an entity to a single table in a relational database.
  58.  *
  59.  * A persister is always responsible for a single entity type.
  60.  *
  61.  * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
  62.  * state of entities onto a relational database when the UnitOfWork is committed,
  63.  * as well as for basic querying of entities and their associations (not DQL).
  64.  *
  65.  * The persisting operations that are invoked during a commit of a UnitOfWork to
  66.  * persist the persistent entity state are:
  67.  *
  68.  *   - {@link addInsert} : To schedule an entity for insertion.
  69.  *   - {@link executeInserts} : To execute all scheduled insertions.
  70.  *   - {@link update} : To update the persistent state of an entity.
  71.  *   - {@link delete} : To delete the persistent state of an entity.
  72.  *
  73.  * As can be seen from the above list, insertions are batched and executed all at once
  74.  * for increased efficiency.
  75.  *
  76.  * The querying operations invoked during a UnitOfWork, either through direct find
  77.  * requests or lazy-loading, are the following:
  78.  *
  79.  *   - {@link load} : Loads (the state of) a single, managed entity.
  80.  *   - {@link loadAll} : Loads multiple, managed entities.
  81.  *   - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
  82.  *   - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
  83.  *   - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
  84.  *
  85.  * The BasicEntityPersister implementation provides the default behavior for
  86.  * persisting and querying entities that are mapped to a single database table.
  87.  *
  88.  * Subclasses can be created to provide custom persisting and querying strategies,
  89.  * i.e. spanning multiple tables.
  90.  *
  91.  * @psalm-import-type AssociationMapping from ClassMetadata
  92.  */
  93. class BasicEntityPersister implements EntityPersister
  94. {
  95.     /** @var array<string,string> */
  96.     private static $comparisonMap = [
  97.         Comparison::EQ          => '= %s',
  98.         Comparison::NEQ         => '!= %s',
  99.         Comparison::GT          => '> %s',
  100.         Comparison::GTE         => '>= %s',
  101.         Comparison::LT          => '< %s',
  102.         Comparison::LTE         => '<= %s',
  103.         Comparison::IN          => 'IN (%s)',
  104.         Comparison::NIN         => 'NOT IN (%s)',
  105.         Comparison::CONTAINS    => 'LIKE %s',
  106.         Comparison::STARTS_WITH => 'LIKE %s',
  107.         Comparison::ENDS_WITH   => 'LIKE %s',
  108.     ];
  110.     /**
  111.      * Metadata object that describes the mapping of the mapped entity class.
  112.      *
  113.      * @var ClassMetadata
  114.      */
  115.     protected $class;
  117.     /**
  118.      * The underlying DBAL Connection of the used EntityManager.
  119.      *
  120.      * @var Connection $conn
  121.      */
  122.     protected $conn;
  124.     /**
  125.      * The database platform.
  126.      *
  127.      * @var AbstractPlatform
  128.      */
  129.     protected $platform;
  131.     /**
  132.      * The EntityManager instance.
  133.      *
  134.      * @var EntityManagerInterface
  135.      */
  136.     protected $em;
  138.     /**
  139.      * Queued inserts.
  140.      *
  141.      * @psalm-var array<int, object>
  142.      */
  143.     protected $queuedInserts = [];
  145.     /**
  146.      * The map of column names to DBAL mapping types of all prepared columns used
  147.      * when INSERTing or UPDATEing an entity.
  148.      *
  149.      * @see prepareInsertData($entity)
  150.      * @see prepareUpdateData($entity)
  151.      *
  152.      * @var mixed[]
  153.      */
  154.     protected $columnTypes = [];
  156.     /**
  157.      * The map of quoted column names.
  158.      *
  159.      * @see prepareInsertData($entity)
  160.      * @see prepareUpdateData($entity)
  161.      *
  162.      * @var mixed[]
  163.      */
  164.     protected $quotedColumns = [];
  166.     /**
  167.      * The INSERT SQL statement used for entities handled by this persister.
  168.      * This SQL is only generated once per request, if at all.
  169.      *
  170.      * @var string|null
  171.      */
  172.     private $insertSql;
  174.     /**
  175.      * The quote strategy.
  176.      *
  177.      * @var QuoteStrategy
  178.      */
  179.     protected $quoteStrategy;
  181.     /**
  182.      * The IdentifierFlattener used for manipulating identifiers
  183.      *
  184.      * @var IdentifierFlattener
  185.      */
  186.     private $identifierFlattener;
  188.     /** @var CachedPersisterContext */
  189.     protected $currentPersisterContext;
  191.     /** @var CachedPersisterContext */
  192.     private $limitsHandlingContext;
  194.     /** @var CachedPersisterContext */
  195.     private $noLimitsContext;
  197.     /**
  198.      * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
  199.      * and persists instances of the class described by the given ClassMetadata descriptor.
  200.      */
  201.     public function __construct(EntityManagerInterface $em, ClassMetadata $class)
  202.     {
  203.         $this->em                    = $em;
  204.         $this->class                 = $class;
  205.         $this->conn                  = $em->getConnection();
  206.         $this->platform              = $this->conn->getDatabasePlatform();
  207.         $this->quoteStrategy         = $em->getConfiguration()->getQuoteStrategy();
  208.         $this->identifierFlattener   = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
  209.         $this->noLimitsContext       = $this->currentPersisterContext = new CachedPersisterContext(
  210.             $class,
  211.             new Query\ResultSetMapping(),
  212.             false
  213.         );
  214.         $this->limitsHandlingContext = new CachedPersisterContext(
  215.             $class,
  216.             new Query\ResultSetMapping(),
  217.             true
  218.         );
  219.     }
  221.     /**
  222.      * {@inheritDoc}
  223.      */
  224.     public function getClassMetadata()
  225.     {
  226.         return $this->class;
  227.     }
  229.     /**
  230.      * {@inheritDoc}
  231.      */
  232.     public function getResultSetMapping()
  233.     {
  234.         return $this->currentPersisterContext->rsm;
  235.     }
  237.     /**
  238.      * {@inheritDoc}
  239.      */
  240.     public function addInsert($entity)
  241.     {
  242.         $this->queuedInserts[spl_object_id($entity)] = $entity;
  243.     }
  245.     /**
  246.      * {@inheritDoc}
  247.      */
  248.     public function getInserts()
  249.     {
  250.         return $this->queuedInserts;
  251.     }
  253.     /**
  254.      * {@inheritDoc}
  255.      */
  256.     public function executeInserts()
  257.     {
  258.         if (! $this->queuedInserts) {
  259.             return [];
  260.         }
  262.         $postInsertIds  = [];
  263.         $idGenerator    = $this->class->idGenerator;
  264.         $isPostInsertId = $idGenerator->isPostInsertGenerator();
  266.         $stmt      = $this->conn->prepare($this->getInsertSQL());
  267.         $tableName = $this->class->getTableName();
  269.         foreach ($this->queuedInserts as $entity) {
  270.             $insertData = $this->prepareInsertData($entity);
  272.             if (isset($insertData[$tableName])) {
  273.                 $paramIndex = 1;
  275.                 foreach ($insertData[$tableName] as $column => $value) {
  276.                     $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$column]);
  277.                 }
  278.             }
  280.             $stmt->executeStatement();
  282.             if ($isPostInsertId) {
  283.                 $generatedId     = $idGenerator->generateId($this->em, $entity);
  284.                 $id              = [$this->class->identifier[0] => $generatedId];
  285.                 $postInsertIds[] = [
  286.                     'generatedId' => $generatedId,
  287.                     'entity' => $entity,
  288.                 ];
  289.             } else {
  290.                 $id = $this->class->getIdentifierValues($entity);
  291.             }
  293.             if ($this->class->requiresFetchAfterChange) {
  294.                 $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  295.             }
  296.         }
  298.         $this->queuedInserts = [];
  300.         return $postInsertIds;
  301.     }
  303.     /**
  304.      * Retrieves the default version value which was created
  305.      * by the preceding INSERT statement and assigns it back in to the
  306.      * entities version field if the given entity is versioned.
  307.      * Also retrieves values of columns marked as 'non insertable' and / or
  308.      * 'not updatable' and assigns them back to the entities corresponding fields.
  309.      *
  310.      * @param object  $entity
  311.      * @param mixed[] $id
  312.      *
  313.      * @return void
  314.      */
  315.     protected function assignDefaultVersionAndUpsertableValues($entity, array $id)
  316.     {
  317.         $values = $this->fetchVersionAndNotUpsertableValues($this->class, $id);
  319.         foreach ($values as $field => $value) {
  320.             $value = Type::getType($this->class->fieldMappings[$field]['type'])->convertToPHPValue($value, $this->platform);
  322.             $this->class->setFieldValue($entity, $field, $value);
  323.         }
  324.     }
  326.     /**
  327.      * Fetches the current version value of a versioned entity and / or the values of fields
  328.      * marked as 'not insertable' and / or 'not updatable'.
  329.      *
  330.      * @param ClassMetadata $versionedClass
  331.      * @param mixed[]       $id
  332.      *
  333.      * @return mixed
  334.      */
  335.     protected function fetchVersionAndNotUpsertableValues($versionedClass, array $id)
  336.     {
  337.         $columnNames = [];
  338.         foreach ($this->class->fieldMappings as $key => $column) {
  339.             if (isset($column['generated']) || ($this->class->isVersioned && $key === $versionedClass->versionField)) {
  340.                 $columnNames[$key] = $this->quoteStrategy->getColumnName($key, $versionedClass, $this->platform);
  341.             }
  342.         }
  344.         $tableName  = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
  345.         $identifier = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
  347.         // FIXME: Order with composite keys might not be correct
  348.         $sql = 'SELECT ' . implode(', ', $columnNames)
  349.             . ' FROM ' . $tableName
  350.             . ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
  352.         $flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
  354.         $values = $this->conn->fetchNumeric(
  355.             $sql,
  356.             array_values($flatId),
  357.             $this->extractIdentifierTypes($id, $versionedClass)
  358.         );
  360.         if ($values === false) {
  361.             throw new LengthException('Unexpected empty result for database query.');
  362.         }
  364.         $values = array_combine(array_keys($columnNames), $values);
  366.         if (! $values) {
  367.             throw new LengthException('Unexpected number of database columns.');
  368.         }
  370.         return $values;
  371.     }
  373.     /**
  374.      * @param mixed[] $id
  375.      *
  376.      * @return int[]|null[]|string[]
  377.      * @psalm-return list<int|string|null>
  378.      */
  379.     private function extractIdentifierTypes(array $id, ClassMetadata $versionedClass): array
  380.     {
  381.         $types = [];
  383.         foreach ($id as $field => $value) {
  384.             $types = array_merge($types, $this->getTypes($field, $value, $versionedClass));
  385.         }
  387.         return $types;
  388.     }
  390.     /**
  391.      * {@inheritDoc}
  392.      */
  393.     public function update($entity)
  394.     {
  395.         $tableName  = $this->class->getTableName();
  396.         $updateData = $this->prepareUpdateData($entity);
  398.         if (! isset($updateData[$tableName])) {
  399.             return;
  400.         }
  402.         $data = $updateData[$tableName];
  404.         if (! $data) {
  405.             return;
  406.         }
  408.         $isVersioned     = $this->class->isVersioned;
  409.         $quotedTableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  411.         $this->updateTable($entity, $quotedTableName, $data, $isVersioned);
  413.         if ($this->class->requiresFetchAfterChange) {
  414.             $id = $this->class->getIdentifierValues($entity);
  416.             $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  417.         }
  418.     }
  420.     /**
  421.      * Performs an UPDATE statement for an entity on a specific table.
  422.      * The UPDATE can optionally be versioned, which requires the entity to have a version field.
  423.      *
  424.      * @param object  $entity          The entity object being updated.
  425.      * @param string  $quotedTableName The quoted name of the table to apply the UPDATE on.
  426.      * @param mixed[] $updateData      The map of columns to update (column => value).
  427.      * @param bool    $versioned       Whether the UPDATE should be versioned.
  428.      *
  429.      * @throws UnrecognizedField
  430.      * @throws OptimisticLockException
  431.      */
  432.     final protected function updateTable(
  433.         $entity,
  434.         $quotedTableName,
  435.         array $updateData,
  436.         $versioned = false
  437.     ): void {
  438.         $set    = [];
  439.         $types  = [];
  440.         $params = [];
  442.         foreach ($updateData as $columnName => $value) {
  443.             $placeholder = '?';
  444.             $column      = $columnName;
  446.             switch (true) {
  447.                 case isset($this->class->fieldNames[$columnName]):
  448.                     $fieldName = $this->class->fieldNames[$columnName];
  449.                     $column    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  451.                     if (isset($this->class->fieldMappings[$fieldName]['requireSQLConversion'])) {
  452.                         $type        = Type::getType($this->columnTypes[$columnName]);
  453.                         $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  454.                     }
  456.                     break;
  458.                 case isset($this->quotedColumns[$columnName]):
  459.                     $column = $this->quotedColumns[$columnName];
  461.                     break;
  462.             }
  464.             $params[] = $value;
  465.             $set[]    = $column . ' = ' . $placeholder;
  466.             $types[]  = $this->columnTypes[$columnName];
  467.         }
  469.         $where      = [];
  470.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  472.         foreach ($this->class->identifier as $idField) {
  473.             if (! isset($this->class->associationMappings[$idField])) {
  474.                 $params[] = $identifier[$idField];
  475.                 $types[]  = $this->class->fieldMappings[$idField]['type'];
  476.                 $where[]  = $this->quoteStrategy->getColumnName($idField, $this->class, $this->platform);
  478.                 continue;
  479.             }
  481.             $params[] = $identifier[$idField];
  482.             $where[]  = $this->quoteStrategy->getJoinColumnName(
  483.                 $this->class->associationMappings[$idField]['joinColumns'][0],
  484.                 $this->class,
  485.                 $this->platform
  486.             );
  488.             $targetMapping = $this->em->getClassMetadata($this->class->associationMappings[$idField]['targetEntity']);
  489.             $targetType    = PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping, $this->em);
  491.             if ($targetType === []) {
  492.                 throw UnrecognizedField::byFullyQualifiedName($this->class->name, $targetMapping->identifier[0]);
  493.             }
  495.             $types[] = reset($targetType);
  496.         }
  498.         if ($versioned) {
  499.             $versionField = $this->class->versionField;
  500.             assert($versionField !== null);
  501.             $versionFieldType = $this->class->fieldMappings[$versionField]['type'];
  502.             $versionColumn    = $this->quoteStrategy->getColumnName($versionField, $this->class, $this->platform);
  504.             $where[]  = $versionColumn;
  505.             $types[]  = $this->class->fieldMappings[$versionField]['type'];
  506.             $params[] = $this->class->reflFields[$versionField]->getValue($entity);
  508.             switch ($versionFieldType) {
  509.                 case Types::SMALLINT:
  510.                 case Types::INTEGER:
  511.                 case Types::BIGINT:
  512.                     $set[] = $versionColumn . ' = ' . $versionColumn . ' + 1';
  513.                     break;
  515.                 case Types::DATETIME_MUTABLE:
  516.                     $set[] = $versionColumn . ' = CURRENT_TIMESTAMP';
  517.                     break;
  518.             }
  519.         }
  521.         $sql = 'UPDATE ' . $quotedTableName
  522.              . ' SET ' . implode(', ', $set)
  523.              . ' WHERE ' . implode(' = ? AND ', $where) . ' = ?';
  525.         $result = $this->conn->executeStatement($sql, $params, $types);
  527.         if ($versioned && ! $result) {
  528.             throw OptimisticLockException::lockFailed($entity);
  529.         }
  530.     }
  532.     /**
  533.      * @param array<mixed> $identifier
  534.      * @param string[]     $types
  535.      *
  536.      * @todo Add check for platform if it supports foreign keys/cascading.
  537.      */
  538.     protected function deleteJoinTableRecords(array $identifier, array $types): void
  539.     {
  540.         foreach ($this->class->associationMappings as $mapping) {
  541.             if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY || isset($mapping['isOnDeleteCascade'])) {
  542.                 continue;
  543.             }
  545.             // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
  546.             // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
  547.             $selfReferential = ($mapping['targetEntity'] === $mapping['sourceEntity']);
  548.             $class           = $this->class;
  549.             $association     = $mapping;
  550.             $otherColumns    = [];
  551.             $otherKeys       = [];
  552.             $keys            = [];
  554.             if (! $mapping['isOwningSide']) {
  555.                 $class       = $this->em->getClassMetadata($mapping['targetEntity']);
  556.                 $association = $class->associationMappings[$mapping['mappedBy']];
  557.             }
  559.             $joinColumns = $mapping['isOwningSide']
  560.                 ? $association['joinTable']['joinColumns']
  561.                 : $association['joinTable']['inverseJoinColumns'];
  563.             if ($selfReferential) {
  564.                 $otherColumns = ! $mapping['isOwningSide']
  565.                     ? $association['joinTable']['joinColumns']
  566.                     : $association['joinTable']['inverseJoinColumns'];
  567.             }
  569.             foreach ($joinColumns as $joinColumn) {
  570.                 $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  571.             }
  573.             foreach ($otherColumns as $joinColumn) {
  574.                 $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  575.             }
  577.             $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  579.             $this->conn->delete($joinTableName, array_combine($keys, $identifier), $types);
  581.             if ($selfReferential) {
  582.                 $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier), $types);
  583.             }
  584.         }
  585.     }
  587.     /**
  588.      * {@inheritDoc}
  589.      */
  590.     public function delete($entity)
  591.     {
  592.         $class      = $this->class;
  593.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  594.         $tableName  = $this->quoteStrategy->getTableName($class, $this->platform);
  595.         $idColumns  = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform);
  596.         $id         = array_combine($idColumns, $identifier);
  597.         $types      = $this->getClassIdentifiersTypes($class);
  599.         $this->deleteJoinTableRecords($identifier, $types);
  601.         return (bool) $this->conn->delete($tableName, $id, $types);
  602.     }
  604.     /**
  605.      * Prepares the changeset of an entity for database insertion (UPDATE).
  606.      *
  607.      * The changeset is obtained from the currently running UnitOfWork.
  608.      *
  609.      * During this preparation the array that is passed as the second parameter is filled with
  610.      * <columnName> => <value> pairs, grouped by table name.
  611.      *
  612.      * Example:
  613.      * <code>
  614.      * array(
  615.      *    'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
  616.      *    'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
  617.      *    ...
  618.      * )
  619.      * </code>
  620.      *
  621.      * @param object $entity   The entity for which to prepare the data.
  622.      * @param bool   $isInsert Whether the data to be prepared refers to an insert statement.
  623.      *
  624.      * @return mixed[][] The prepared data.
  625.      * @psalm-return array<string, array<array-key, mixed|null>>
  626.      */
  627.     protected function prepareUpdateData($entity, bool $isInsert = false)
  628.     {
  629.         $versionField = null;
  630.         $result       = [];
  631.         $uow          = $this->em->getUnitOfWork();
  633.         $versioned = $this->class->isVersioned;
  634.         if ($versioned !== false) {
  635.             $versionField = $this->class->versionField;
  636.         }
  638.         foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
  639.             if (isset($versionField) && $versionField === $field) {
  640.                 continue;
  641.             }
  643.             if (isset($this->class->embeddedClasses[$field])) {
  644.                 continue;
  645.             }
  647.             $newVal = $change[1];
  649.             if (! isset($this->class->associationMappings[$field])) {
  650.                 $fieldMapping = $this->class->fieldMappings[$field];
  651.                 $columnName   = $fieldMapping['columnName'];
  653.                 if (! $isInsert && isset($fieldMapping['notUpdatable'])) {
  654.                     continue;
  655.                 }
  657.                 if ($isInsert && isset($fieldMapping['notInsertable'])) {
  658.                     continue;
  659.                 }
  661.                 $this->columnTypes[$columnName] = $fieldMapping['type'];
  663.                 $result[$this->getOwningTable($field)][$columnName] = $newVal;
  665.                 continue;
  666.             }
  668.             $assoc = $this->class->associationMappings[$field];
  670.             // Only owning side of x-1 associations can have a FK column.
  671.             if (! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
  672.                 continue;
  673.             }
  675.             if ($newVal !== null) {
  676.                 $oid = spl_object_id($newVal);
  678.                 if (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal)) {
  679.                     // The associated entity $newVal is not yet persisted, so we must
  680.                     // set $newVal = null, in order to insert a null value and schedule an
  681.                     // extra update on the UnitOfWork.
  682.                     $uow->scheduleExtraUpdate($entity, [$field => [null, $newVal]]);
  684.                     $newVal = null;
  685.                 }
  686.             }
  688.             $newValId = null;
  690.             if ($newVal !== null) {
  691.                 $newValId = $uow->getEntityIdentifier($newVal);
  692.             }
  694.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  695.             $owningTable = $this->getOwningTable($field);
  697.             foreach ($assoc['joinColumns'] as $joinColumn) {
  698.                 $sourceColumn = $joinColumn['name'];
  699.                 $targetColumn = $joinColumn['referencedColumnName'];
  700.                 $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  702.                 $this->quotedColumns[$sourceColumn]  = $quotedColumn;
  703.                 $this->columnTypes[$sourceColumn]    = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
  704.                 $result[$owningTable][$sourceColumn] = $newValId
  705.                     ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
  706.                     : null;
  707.             }
  708.         }
  710.         return $result;
  711.     }
  713.     /**
  714.      * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
  715.      * The changeset of the entity is obtained from the currently running UnitOfWork.
  716.      *
  717.      * The default insert data preparation is the same as for updates.
  718.      *
  719.      * @see prepareUpdateData
  720.      *
  721.      * @param object $entity The entity for which to prepare the data.
  722.      *
  723.      * @return mixed[][] The prepared data for the tables to update.
  724.      * @psalm-return array<string, mixed[]>
  725.      */
  726.     protected function prepareInsertData($entity)
  727.     {
  728.         return $this->prepareUpdateData($entity, true);
  729.     }
  731.     /**
  732.      * {@inheritDoc}
  733.      */
  734.     public function getOwningTable($fieldName)
  735.     {
  736.         return $this->class->getTableName();
  737.     }
  739.     /**
  740.      * {@inheritDoc}
  741.      */
  742.     public function load(array $criteria, $entity = null, $assoc = null, array $hints = [], $lockMode = null, $limit = null, ?array $orderBy = null)
  743.     {
  744.         $this->switchPersisterContext(null, $limit);
  746.         $sql              = $this->getSelectSQL($criteria, $assoc, $lockMode, $limit, null, $orderBy);
  747.         [$params, $types] = $this->expandParameters($criteria);
  748.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  750.         if ($entity !== null) {
  751.             $hints[Query::HINT_REFRESH]        = true;
  752.             $hints[Query::HINT_REFRESH_ENTITY] = $entity;
  753.         }
  755.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  756.         $entities = $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, $hints);
  758.         return $entities ? $entities[0] : null;
  759.     }
  761.     /**
  762.      * {@inheritDoc}
  763.      */
  764.     public function loadById(array $identifier, $entity = null)
  765.     {
  766.         return $this->load($identifier, $entity);
  767.     }
  769.     /**
  770.      * {@inheritDoc}
  771.      */
  772.     public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
  773.     {
  774.         $foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc['targetEntity']);
  775.         if ($foundEntity !== false) {
  776.             return $foundEntity;
  777.         }
  779.         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  781.         if ($assoc['isOwningSide']) {
  782.             $isInverseSingleValued = $assoc['inversedBy'] && ! $targetClass->isCollectionValuedAssociation($assoc['inversedBy']);
  784.             // Mark inverse side as fetched in the hints, otherwise the UoW would
  785.             // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
  786.             $hints = [];
  788.             if ($isInverseSingleValued) {
  789.                 $hints['fetched']['r'][$assoc['inversedBy']] = true;
  790.             }
  792.             $targetEntity = $this->load($identifier, null, $assoc, $hints);
  794.             // Complete bidirectional association, if necessary
  795.             if ($targetEntity !== null && $isInverseSingleValued) {
  796.                 $targetClass->reflFields[$assoc['inversedBy']]->setValue($targetEntity, $sourceEntity);
  797.             }
  799.             return $targetEntity;
  800.         }
  802.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  803.         $owningAssoc = $targetClass->getAssociationMapping($assoc['mappedBy']);
  805.         $computedIdentifier = [];
  807.         // TRICKY: since the association is specular source and target are flipped
  808.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  809.             if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
  810.                 throw MappingException::joinColumnMustPointToMappedField(
  811.                     $sourceClass->name,
  812.                     $sourceKeyColumn
  813.                 );
  814.             }
  816.             $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  817.                 $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
  818.         }
  820.         $targetEntity = $this->load($computedIdentifier, null, $assoc);
  822.         if ($targetEntity !== null) {
  823.             $targetClass->setFieldValue($targetEntity, $assoc['mappedBy'], $sourceEntity);
  824.         }
  826.         return $targetEntity;
  827.     }
  829.     /**
  830.      * {@inheritDoc}
  831.      */
  832.     public function refresh(array $id, $entity, $lockMode = null)
  833.     {
  834.         $sql              = $this->getSelectSQL($id, null, $lockMode);
  835.         [$params, $types] = $this->expandParameters($id);
  836.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  838.         $hydrator = $this->em->newHydrator(Query::HYDRATE_OBJECT);
  839.         $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
  840.     }
  842.     /**
  843.      * {@inheritDoc}
  844.      */
  845.     public function count($criteria = [])
  846.     {
  847.         $sql = $this->getCountSQL($criteria);
  849.         [$params, $types] = $criteria instanceof Criteria
  850.             ? $this->expandCriteriaParameters($criteria)
  851.             : $this->expandParameters($criteria);
  853.         return (int) $this->conn->executeQuery($sql, $params, $types)->fetchOne();
  854.     }
  856.     /**
  857.      * {@inheritDoc}
  858.      */
  859.     public function loadCriteria(Criteria $criteria)
  860.     {
  861.         $orderBy = $criteria->getOrderings();
  862.         $limit   = $criteria->getMaxResults();
  863.         $offset  = $criteria->getFirstResult();
  864.         $query   = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  866.         [$params, $types] = $this->expandCriteriaParameters($criteria);
  868.         $stmt     = $this->conn->executeQuery($query, $params, $types);
  869.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  871.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  872.     }
  874.     /**
  875.      * {@inheritDoc}
  876.      */
  877.     public function expandCriteriaParameters(Criteria $criteria)
  878.     {
  879.         $expression = $criteria->getWhereExpression();
  880.         $sqlParams  = [];
  881.         $sqlTypes   = [];
  883.         if ($expression === null) {
  884.             return [$sqlParams, $sqlTypes];
  885.         }
  887.         $valueVisitor = new SqlValueVisitor();
  889.         $valueVisitor->dispatch($expression);
  891.         [, $types] = $valueVisitor->getParamsAndTypes();
  893.         foreach ($types as $type) {
  894.             [$field, $value, $operator] = $type;
  896.             if ($value === null && ($operator === Comparison::EQ || $operator === Comparison::NEQ)) {
  897.                 continue;
  898.             }
  900.             $sqlParams = array_merge($sqlParams, $this->getValues($value));
  901.             $sqlTypes  = array_merge($sqlTypes, $this->getTypes($field, $value, $this->class));
  902.         }
  904.         return [$sqlParams, $sqlTypes];
  905.     }
  907.     /**
  908.      * {@inheritDoc}
  909.      */
  910.     public function loadAll(array $criteria = [], ?array $orderBy = null, $limit = null, $offset = null)
  911.     {
  912.         $this->switchPersisterContext($offset, $limit);
  914.         $sql              = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  915.         [$params, $types] = $this->expandParameters($criteria);
  916.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  918.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  920.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  921.     }
  923.     /**
  924.      * {@inheritDoc}
  925.      */
  926.     public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  927.     {
  928.         $this->switchPersisterContext($offset, $limit);
  930.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity, $offset, $limit);
  932.         return $this->loadArrayFromResult($assoc, $stmt);
  933.     }
  935.     /**
  936.      * Loads an array of entities from a given DBAL statement.
  937.      *
  938.      * @param mixed[] $assoc
  939.      *
  940.      * @return mixed[]
  941.      */
  942.     private function loadArrayFromResult(array $assoc, Result $stmt): array
  943.     {
  944.         $rsm   = $this->currentPersisterContext->rsm;
  945.         $hints = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
  947.         if (isset($assoc['indexBy'])) {
  948.             $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  949.             $rsm->addIndexBy('r', $assoc['indexBy']);
  950.         }
  952.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  953.     }
  955.     /**
  956.      * Hydrates a collection from a given DBAL statement.
  957.      *
  958.      * @param mixed[] $assoc
  959.      *
  960.      * @return mixed[]
  961.      */
  962.     private function loadCollectionFromStatement(
  963.         array $assoc,
  964.         Result $stmt,
  965.         PersistentCollection $coll
  966.     ): array {
  967.         $rsm   = $this->currentPersisterContext->rsm;
  968.         $hints = [
  969.             UnitOfWork::HINT_DEFEREAGERLOAD => true,
  970.             'collection' => $coll,
  971.         ];
  973.         if (isset($assoc['indexBy'])) {
  974.             $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  975.             $rsm->addIndexBy('r', $assoc['indexBy']);
  976.         }
  978.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  979.     }
  981.     /**
  982.      * {@inheritDoc}
  983.      */
  984.     public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  985.     {
  986.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity);
  988.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  989.     }
  991.     /**
  992.      * @param object $sourceEntity
  993.      * @psalm-param array<string, mixed> $assoc
  994.      *
  995.      * @return Result
  996.      *
  997.      * @throws MappingException
  998.      */
  999.     private function getManyToManyStatement(
  1000.         array $assoc,
  1001.         $sourceEntity,
  1002.         ?int $offset = null,
  1003.         ?int $limit = null
  1004.     ) {
  1005.         $this->switchPersisterContext($offset, $limit);
  1007.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1008.         $class       = $sourceClass;
  1009.         $association = $assoc;
  1010.         $criteria    = [];
  1011.         $parameters  = [];
  1013.         if (! $assoc['isOwningSide']) {
  1014.             $class       = $this->em->getClassMetadata($assoc['targetEntity']);
  1015.             $association = $class->associationMappings[$assoc['mappedBy']];
  1016.         }
  1018.         $joinColumns = $assoc['isOwningSide']
  1019.             ? $association['joinTable']['joinColumns']
  1020.             : $association['joinTable']['inverseJoinColumns'];
  1022.         $quotedJoinTable = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1024.         foreach ($joinColumns as $joinColumn) {
  1025.             $sourceKeyColumn = $joinColumn['referencedColumnName'];
  1026.             $quotedKeyColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1028.             switch (true) {
  1029.                 case $sourceClass->containsForeignIdentifier:
  1030.                     $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1031.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1033.                     if (isset($sourceClass->associationMappings[$field])) {
  1034.                         $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1035.                         $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1036.                     }
  1038.                     break;
  1040.                 case isset($sourceClass->fieldNames[$sourceKeyColumn]):
  1041.                     $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1042.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1044.                     break;
  1046.                 default:
  1047.                     throw MappingException::joinColumnMustPointToMappedField(
  1048.                         $sourceClass->name,
  1049.                         $sourceKeyColumn
  1050.                     );
  1051.             }
  1053.             $criteria[$quotedJoinTable . '.' . $quotedKeyColumn] = $value;
  1054.             $parameters[]                                        = [
  1055.                 'value' => $value,
  1056.                 'field' => $field,
  1057.                 'class' => $sourceClass,
  1058.             ];
  1059.         }
  1061.         $sql              = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1062.         [$params, $types] = $this->expandToManyParameters($parameters);
  1064.         return $this->conn->executeQuery($sql, $params, $types);
  1065.     }
  1067.     /**
  1068.      * {@inheritDoc}
  1069.      */
  1070.     public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, ?array $orderBy = null)
  1071.     {
  1072.         $this->switchPersisterContext($offset, $limit);
  1074.         $lockSql    = '';
  1075.         $joinSql    = '';
  1076.         $orderBySql = '';
  1078.         if ($assoc !== null && $assoc['type'] === ClassMetadata::MANY_TO_MANY) {
  1079.             $joinSql = $this->getSelectManyToManyJoinSQL($assoc);
  1080.         }
  1082.         if (isset($assoc['orderBy'])) {
  1083.             $orderBy = $assoc['orderBy'];
  1084.         }
  1086.         if ($orderBy) {
  1087.             $orderBySql = $this->getOrderBySQL($orderBy, $this->getSQLTableAlias($this->class->name));
  1088.         }
  1090.         $conditionSql = $criteria instanceof Criteria
  1091.             ? $this->getSelectConditionCriteriaSQL($criteria)
  1092.             : $this->getSelectConditionSQL($criteria, $assoc);
  1094.         switch ($lockMode) {
  1095.             case LockMode::PESSIMISTIC_READ:
  1096.                 $lockSql = ' ' . $this->platform->getReadLockSQL();
  1097.                 break;
  1099.             case LockMode::PESSIMISTIC_WRITE:
  1100.                 $lockSql = ' ' . $this->platform->getWriteLockSQL();
  1101.                 break;
  1102.         }
  1104.         $columnList = $this->getSelectColumnsSQL();
  1105.         $tableAlias = $this->getSQLTableAlias($this->class->name);
  1106.         $filterSql  = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1107.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1109.         if ($filterSql !== '') {
  1110.             $conditionSql = $conditionSql
  1111.                 ? $conditionSql . ' AND ' . $filterSql
  1112.                 : $filterSql;
  1113.         }
  1115.         $select = 'SELECT ' . $columnList;
  1116.         $from   = ' FROM ' . $tableName . ' ' . $tableAlias;
  1117.         $join   = $this->currentPersisterContext->selectJoinSql . $joinSql;
  1118.         $where  = ($conditionSql ? ' WHERE ' . $conditionSql : '');
  1119.         $lock   = $this->platform->appendLockHint($from, $lockMode ?? LockMode::NONE);
  1120.         $query  = $select
  1121.             . $lock
  1122.             . $join
  1123.             . $where
  1124.             . $orderBySql;
  1126.         return $this->platform->modifyLimitQuery($query, $limit, $offset ?? 0) . $lockSql;
  1127.     }
  1129.     /**
  1130.      * {@inheritDoc}
  1131.      */
  1132.     public function getCountSQL($criteria = [])
  1133.     {
  1134.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1135.         $tableAlias = $this->getSQLTableAlias($this->class->name);
  1137.         $conditionSql = $criteria instanceof Criteria
  1138.             ? $this->getSelectConditionCriteriaSQL($criteria)
  1139.             : $this->getSelectConditionSQL($criteria);
  1141.         $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1143.         if ($filterSql !== '') {
  1144.             $conditionSql = $conditionSql
  1145.                 ? $conditionSql . ' AND ' . $filterSql
  1146.                 : $filterSql;
  1147.         }
  1149.         return 'SELECT COUNT(*) '
  1150.             . 'FROM ' . $tableName . ' ' . $tableAlias
  1151.             . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
  1152.     }
  1154.     /**
  1155.      * Gets the ORDER BY SQL snippet for ordered collections.
  1156.      *
  1157.      * @psalm-param array<string, string> $orderBy
  1158.      *
  1159.      * @throws InvalidOrientation
  1160.      * @throws InvalidFindByCall
  1161.      * @throws UnrecognizedField
  1162.      */
  1163.     final protected function getOrderBySQL(array $orderBy, string $baseTableAlias): string
  1164.     {
  1165.         $orderByList = [];
  1167.         foreach ($orderBy as $fieldName => $orientation) {
  1168.             $orientation = strtoupper(trim($orientation));
  1170.             if ($orientation !== 'ASC' && $orientation !== 'DESC') {
  1171.                 throw InvalidOrientation::fromClassNameAndField($this->class->name, $fieldName);
  1172.             }
  1174.             if (isset($this->class->fieldMappings[$fieldName])) {
  1175.                 $tableAlias = isset($this->class->fieldMappings[$fieldName]['inherited'])
  1176.                     ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
  1177.                     : $baseTableAlias;
  1179.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  1180.                 $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1182.                 continue;
  1183.             }
  1185.             if (isset($this->class->associationMappings[$fieldName])) {
  1186.                 if (! $this->class->associationMappings[$fieldName]['isOwningSide']) {
  1187.                     throw InvalidFindByCall::fromInverseSideUsage($this->class->name, $fieldName);
  1188.                 }
  1190.                 $tableAlias = isset($this->class->associationMappings[$fieldName]['inherited'])
  1191.                     ? $this->getSQLTableAlias($this->class->associationMappings[$fieldName]['inherited'])
  1192.                     : $baseTableAlias;
  1194.                 foreach ($this->class->associationMappings[$fieldName]['joinColumns'] as $joinColumn) {
  1195.                     $columnName    = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1196.                     $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1197.                 }
  1199.                 continue;
  1200.             }
  1202.             throw UnrecognizedField::byFullyQualifiedName($this->class->name, $fieldName);
  1203.         }
  1205.         return ' ORDER BY ' . implode(', ', $orderByList);
  1206.     }
  1208.     /**
  1209.      * Gets the SQL fragment with the list of columns to select when querying for
  1210.      * an entity in this persister.
  1211.      *
  1212.      * Subclasses should override this method to alter or change the select column
  1213.      * list SQL fragment. Note that in the implementation of BasicEntityPersister
  1214.      * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
  1215.      * Subclasses may or may not do the same.
  1216.      *
  1217.      * @return string The SQL fragment.
  1218.      */
  1219.     protected function getSelectColumnsSQL()
  1220.     {
  1221.         if ($this->currentPersisterContext->selectColumnListSql !== null) {
  1222.             return $this->currentPersisterContext->selectColumnListSql;
  1223.         }
  1225.         $columnList = [];
  1226.         $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r'); // r for root
  1228.         // Add regular columns to select list
  1229.         foreach ($this->class->fieldNames as $field) {
  1230.             $columnList[] = $this->getSelectColumnSQL($field, $this->class);
  1231.         }
  1233.         $this->currentPersisterContext->selectJoinSql = '';
  1234.         $eagerAliasCounter                            = 0;
  1236.         foreach ($this->class->associationMappings as $assocField => $assoc) {
  1237.             $assocColumnSQL = $this->getSelectColumnAssociationSQL($assocField, $assoc, $this->class);
  1239.             if ($assocColumnSQL) {
  1240.                 $columnList[] = $assocColumnSQL;
  1241.             }
  1243.             $isAssocToOneInverseSide = $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
  1244.             $isAssocFromOneEager     = $assoc['type'] !== ClassMetadata::MANY_TO_MANY && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
  1246.             if (! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
  1247.                 continue;
  1248.             }
  1250.             if ((($assoc['type'] & ClassMetadata::TO_MANY) > 0) && $this->currentPersisterContext->handlesLimits) {
  1251.                 continue;
  1252.             }
  1254.             $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1256.             if ($eagerEntity->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  1257.                 continue; // now this is why you shouldn't use inheritance
  1258.             }
  1260.             $assocAlias = 'e' . ($eagerAliasCounter++);
  1261.             $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc['targetEntity'], $assocAlias, 'r', $assocField);
  1263.             foreach ($eagerEntity->fieldNames as $field) {
  1264.                 $columnList[] = $this->getSelectColumnSQL($field, $eagerEntity, $assocAlias);
  1265.             }
  1267.             foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
  1268.                 $eagerAssocColumnSQL = $this->getSelectColumnAssociationSQL(
  1269.                     $eagerAssocField,
  1270.                     $eagerAssoc,
  1271.                     $eagerEntity,
  1272.                     $assocAlias
  1273.                 );
  1275.                 if ($eagerAssocColumnSQL) {
  1276.                     $columnList[] = $eagerAssocColumnSQL;
  1277.                 }
  1278.             }
  1280.             $association   = $assoc;
  1281.             $joinCondition = [];
  1283.             if (isset($assoc['indexBy'])) {
  1284.                 $this->currentPersisterContext->rsm->addIndexBy($assocAlias, $assoc['indexBy']);
  1285.             }
  1287.             if (! $assoc['isOwningSide']) {
  1288.                 $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1289.                 $association = $eagerEntity->getAssociationMapping($assoc['mappedBy']);
  1290.             }
  1292.             $joinTableAlias = $this->getSQLTableAlias($eagerEntity->name, $assocAlias);
  1293.             $joinTableName  = $this->quoteStrategy->getTableName($eagerEntity, $this->platform);
  1295.             if ($assoc['isOwningSide']) {
  1296.                 $tableAlias                                    = $this->getSQLTableAlias($association['targetEntity'], $assocAlias);
  1297.                 $this->currentPersisterContext->selectJoinSql .= ' ' . $this->getJoinSQLForJoinColumns($association['joinColumns']);
  1299.                 foreach ($association['joinColumns'] as $joinColumn) {
  1300.                     $sourceCol       = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1301.                     $targetCol       = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1302.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'])
  1303.                                         . '.' . $sourceCol . ' = ' . $tableAlias . '.' . $targetCol;
  1304.                 }
  1306.                 // Add filter SQL
  1307.                 $filterSql = $this->generateFilterConditionSQL($eagerEntity, $tableAlias);
  1308.                 if ($filterSql) {
  1309.                     $joinCondition[] = $filterSql;
  1310.                 }
  1311.             } else {
  1312.                 $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
  1314.                 foreach ($association['joinColumns'] as $joinColumn) {
  1315.                     $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1316.                     $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1318.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'], $assocAlias) . '.' . $sourceCol . ' = '
  1319.                         . $this->getSQLTableAlias($association['targetEntity']) . '.' . $targetCol;
  1320.                 }
  1321.             }
  1323.             $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';
  1324.             $this->currentPersisterContext->selectJoinSql .= implode(' AND ', $joinCondition);
  1325.         }
  1327.         $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
  1329.         return $this->currentPersisterContext->selectColumnListSql;
  1330.     }
  1332.     /**
  1333.      * Gets the SQL join fragment used when selecting entities from an association.
  1334.      *
  1335.      * @param string             $field
  1336.      * @param AssociationMapping $assoc
  1337.      * @param string             $alias
  1338.      *
  1339.      * @return string
  1340.      */
  1341.     protected function getSelectColumnAssociationSQL($field, $assoc, ClassMetadata $class, $alias = 'r')
  1342.     {
  1343.         if (! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)) {
  1344.             return '';
  1345.         }
  1347.         $columnList    = [];
  1348.         $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
  1349.         $isIdentifier  = isset($assoc['id']) && $assoc['id'] === true;
  1350.         $sqlTableAlias = $this->getSQLTableAlias($class->name, ($alias === 'r' ? '' : $alias));
  1352.         foreach ($assoc['joinColumns'] as $joinColumn) {
  1353.             $quotedColumn     = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1354.             $resultColumnName = $this->getSQLColumnAlias($joinColumn['name']);
  1355.             $type             = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  1357.             $this->currentPersisterContext->rsm->addMetaResult($alias, $resultColumnName, $joinColumn['name'], $isIdentifier, $type);
  1359.             $columnList[] = sprintf('%s.%s AS %s', $sqlTableAlias, $quotedColumn, $resultColumnName);
  1360.         }
  1362.         return implode(', ', $columnList);
  1363.     }
  1365.     /**
  1366.      * Gets the SQL join fragment used when selecting entities from a
  1367.      * many-to-many association.
  1368.      *
  1369.      * @psalm-param AssociationMapping $manyToMany
  1370.      *
  1371.      * @return string
  1372.      */
  1373.     protected function getSelectManyToManyJoinSQL(array $manyToMany)
  1374.     {
  1375.         $conditions       = [];
  1376.         $association      = $manyToMany;
  1377.         $sourceTableAlias = $this->getSQLTableAlias($this->class->name);
  1379.         if (! $manyToMany['isOwningSide']) {
  1380.             $targetEntity = $this->em->getClassMetadata($manyToMany['targetEntity']);
  1381.             $association  = $targetEntity->associationMappings[$manyToMany['mappedBy']];
  1382.         }
  1384.         $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  1385.         $joinColumns   = $manyToMany['isOwningSide']
  1386.             ? $association['joinTable']['inverseJoinColumns']
  1387.             : $association['joinTable']['joinColumns'];
  1389.         foreach ($joinColumns as $joinColumn) {
  1390.             $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1391.             $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1392.             $conditions[]       = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableName . '.' . $quotedSourceColumn;
  1393.         }
  1395.         return ' INNER JOIN ' . $joinTableName . ' ON ' . implode(' AND ', $conditions);
  1396.     }
  1398.     /**
  1399.      * {@inheritDoc}
  1400.      */
  1401.     public function getInsertSQL()
  1402.     {
  1403.         if ($this->insertSql !== null) {
  1404.             return $this->insertSql;
  1405.         }
  1407.         $columns   = $this->getInsertColumnList();
  1408.         $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1410.         if (empty($columns)) {
  1411.             $identityColumn  = $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class, $this->platform);
  1412.             $this->insertSql = $this->platform->getEmptyIdentityInsertSQL($tableName, $identityColumn);
  1414.             return $this->insertSql;
  1415.         }
  1417.         $values  = [];
  1418.         $columns = array_unique($columns);
  1420.         foreach ($columns as $column) {
  1421.             $placeholder = '?';
  1423.             if (
  1424.                 isset($this->class->fieldNames[$column])
  1425.                 && isset($this->columnTypes[$this->class->fieldNames[$column]])
  1426.                 && isset($this->class->fieldMappings[$this->class->fieldNames[$column]]['requireSQLConversion'])
  1427.             ) {
  1428.                 $type        = Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
  1429.                 $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  1430.             }
  1432.             $values[] = $placeholder;
  1433.         }
  1435.         $columns = implode(', ', $columns);
  1436.         $values  = implode(', ', $values);
  1438.         $this->insertSql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tableName, $columns, $values);
  1440.         return $this->insertSql;
  1441.     }
  1443.     /**
  1444.      * Gets the list of columns to put in the INSERT SQL statement.
  1445.      *
  1446.      * Subclasses should override this method to alter or change the list of
  1447.      * columns placed in the INSERT statements used by the persister.
  1448.      *
  1449.      * @return string[] The list of columns.
  1450.      * @psalm-return list<string>
  1451.      */
  1452.     protected function getInsertColumnList()
  1453.     {
  1454.         $columns = [];
  1456.         foreach ($this->class->reflFields as $name => $field) {
  1457.             if ($this->class->isVersioned && $this->class->versionField === $name) {
  1458.                 continue;
  1459.             }
  1461.             if (isset($this->class->embeddedClasses[$name])) {
  1462.                 continue;
  1463.             }
  1465.             if (isset($this->class->associationMappings[$name])) {
  1466.                 $assoc = $this->class->associationMappings[$name];
  1468.                 if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  1469.                     foreach ($assoc['joinColumns'] as $joinColumn) {
  1470.                         $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1471.                     }
  1472.                 }
  1474.                 continue;
  1475.             }
  1477.             if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] !== $name) {
  1478.                 if (isset($this->class->fieldMappings[$name]['notInsertable'])) {
  1479.                     continue;
  1480.                 }
  1482.                 $columns[]                = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
  1483.                 $this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
  1484.             }
  1485.         }
  1487.         return $columns;
  1488.     }
  1490.     /**
  1491.      * Gets the SQL snippet of a qualified column name for the given field name.
  1492.      *
  1493.      * @param string        $field The field name.
  1494.      * @param ClassMetadata $class The class that declares this field. The table this class is
  1495.      *                             mapped to must own the column for the given field.
  1496.      * @param string        $alias
  1497.      *
  1498.      * @return string
  1499.      */
  1500.     protected function getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r')
  1501.     {
  1502.         $root         = $alias === 'r' ? '' : $alias;
  1503.         $tableAlias   = $this->getSQLTableAlias($class->name, $root);
  1504.         $fieldMapping = $class->fieldMappings[$field];
  1505.         $sql          = sprintf('%s.%s', $tableAlias, $this->quoteStrategy->getColumnName($field, $class, $this->platform));
  1506.         $columnAlias  = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1508.         $this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field);
  1509.         if (! empty($fieldMapping['enumType'])) {
  1510.             $this->currentPersisterContext->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
  1511.         }
  1513.         if (isset($fieldMapping['requireSQLConversion'])) {
  1514.             $type = Type::getType($fieldMapping['type']);
  1515.             $sql  = $type->convertToPHPValueSQL($sql, $this->platform);
  1516.         }
  1518.         return $sql . ' AS ' . $columnAlias;
  1519.     }
  1521.     /**
  1522.      * Gets the SQL table alias for the given class name.
  1523.      *
  1524.      * @param string $className
  1525.      * @param string $assocName
  1526.      *
  1527.      * @return string The SQL table alias.
  1528.      *
  1529.      * @todo Reconsider. Binding table aliases to class names is not such a good idea.
  1530.      */
  1531.     protected function getSQLTableAlias($className, $assocName = '')
  1532.     {
  1533.         if ($assocName) {
  1534.             $className .= '#' . $assocName;
  1535.         }
  1537.         if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
  1538.             return $this->currentPersisterContext->sqlTableAliases[$className];
  1539.         }
  1541.         $tableAlias = 't' . $this->currentPersisterContext->sqlAliasCounter++;
  1543.         $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
  1545.         return $tableAlias;
  1546.     }
  1548.     /**
  1549.      * {@inheritDoc}
  1550.      */
  1551.     public function lock(array $criteria, $lockMode)
  1552.     {
  1553.         $lockSql      = '';
  1554.         $conditionSql = $this->getSelectConditionSQL($criteria);
  1556.         switch ($lockMode) {
  1557.             case LockMode::PESSIMISTIC_READ:
  1558.                 $lockSql = $this->platform->getReadLockSQL();
  1560.                 break;
  1561.             case LockMode::PESSIMISTIC_WRITE:
  1562.                 $lockSql = $this->platform->getWriteLockSQL();
  1563.                 break;
  1564.         }
  1566.         $lock  = $this->getLockTablesSql($lockMode);
  1567.         $where = ($conditionSql ? ' WHERE ' . $conditionSql : '') . ' ';
  1568.         $sql   = 'SELECT 1 '
  1569.              . $lock
  1570.              . $where
  1571.              . $lockSql;
  1573.         [$params, $types] = $this->expandParameters($criteria);
  1575.         $this->conn->executeQuery($sql, $params, $types);
  1576.     }
  1578.     /**
  1579.      * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
  1580.      *
  1581.      * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants.
  1582.      * @psalm-param LockMode::*|null $lockMode
  1583.      *
  1584.      * @return string
  1585.      */
  1586.     protected function getLockTablesSql($lockMode)
  1587.     {
  1588.         if ($lockMode === null) {
  1589.             Deprecation::trigger(
  1590.                 'doctrine/orm',
  1591.                 'https://github.com/doctrine/orm/pull/9466',
  1592.                 'Passing null as argument to %s is deprecated, pass LockMode::NONE instead.',
  1593.                 __METHOD__
  1594.             );
  1596.             $lockMode = LockMode::NONE;
  1597.         }
  1599.         return $this->platform->appendLockHint(
  1600.             'FROM '
  1601.             . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
  1602.             . $this->getSQLTableAlias($this->class->name),
  1603.             $lockMode
  1604.         );
  1605.     }
  1607.     /**
  1608.      * Gets the Select Where Condition from a Criteria object.
  1609.      *
  1610.      * @return string
  1611.      */
  1612.     protected function getSelectConditionCriteriaSQL(Criteria $criteria)
  1613.     {
  1614.         $expression = $criteria->getWhereExpression();
  1616.         if ($expression === null) {
  1617.             return '';
  1618.         }
  1620.         $visitor = new SqlExpressionVisitor($this, $this->class);
  1622.         return $visitor->dispatch($expression);
  1623.     }
  1625.     /**
  1626.      * {@inheritDoc}
  1627.      */
  1628.     public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
  1629.     {
  1630.         $selectedColumns = [];
  1631.         $columns         = $this->getSelectConditionStatementColumnSQL($field, $assoc);
  1633.         if (count($columns) > 1 && $comparison === Comparison::IN) {
  1634.             /*
  1635.              *  @todo try to support multi-column IN expressions.
  1636.              *  Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
  1637.              */
  1638.             throw CantUseInOperatorOnCompositeKeys::create();
  1639.         }
  1641.         foreach ($columns as $column) {
  1642.             $placeholder = '?';
  1644.             if (isset($this->class->fieldMappings[$field]['requireSQLConversion'])) {
  1645.                 $type        = Type::getType($this->class->fieldMappings[$field]['type']);
  1646.                 $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->platform);
  1647.             }
  1649.             if ($comparison !== null) {
  1650.                 // special case null value handling
  1651.                 if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && $value === null) {
  1652.                     $selectedColumns[] = $column . ' IS NULL';
  1654.                     continue;
  1655.                 }
  1657.                 if ($comparison === Comparison::NEQ && $value === null) {
  1658.                     $selectedColumns[] = $column . ' IS NOT NULL';
  1660.                     continue;
  1661.                 }
  1663.                 $selectedColumns[] = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
  1665.                 continue;
  1666.             }
  1668.             if (is_array($value)) {
  1669.                 $in = sprintf('%s IN (%s)', $column, $placeholder);
  1671.                 if (array_search(null, $value, true) !== false) {
  1672.                     $selectedColumns[] = sprintf('(%s OR %s IS NULL)', $in, $column);
  1674.                     continue;
  1675.                 }
  1677.                 $selectedColumns[] = $in;
  1679.                 continue;
  1680.             }
  1682.             if ($value === null) {
  1683.                 $selectedColumns[] = sprintf('%s IS NULL', $column);
  1685.                 continue;
  1686.             }
  1688.             $selectedColumns[] = sprintf('%s = %s', $column, $placeholder);
  1689.         }
  1691.         return implode(' AND ', $selectedColumns);
  1692.     }
  1694.     /**
  1695.      * Builds the left-hand-side of a where condition statement.
  1696.      *
  1697.      * @psalm-param AssociationMapping|null $assoc
  1698.      *
  1699.      * @return string[]
  1700.      * @psalm-return list<string>
  1701.      *
  1702.      * @throws InvalidFindByCall
  1703.      * @throws UnrecognizedField
  1704.      */
  1705.     private function getSelectConditionStatementColumnSQL(
  1706.         string $field,
  1707.         ?array $assoc = null
  1708.     ): array {
  1709.         if (isset($this->class->fieldMappings[$field])) {
  1710.             $className = $this->class->fieldMappings[$field]['inherited'] ?? $this->class->name;
  1712.             return [$this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getColumnName($field, $this->class, $this->platform)];
  1713.         }
  1715.         if (isset($this->class->associationMappings[$field])) {
  1716.             $association = $this->class->associationMappings[$field];
  1717.             // Many-To-Many requires join table check for joinColumn
  1718.             $columns = [];
  1719.             $class   = $this->class;
  1721.             if ($association['type'] === ClassMetadata::MANY_TO_MANY) {
  1722.                 if (! $association['isOwningSide']) {
  1723.                     $association = $assoc;
  1724.                 }
  1726.                 $joinTableName = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1727.                 $joinColumns   = $assoc['isOwningSide']
  1728.                     ? $association['joinTable']['joinColumns']
  1729.                     : $association['joinTable']['inverseJoinColumns'];
  1731.                 foreach ($joinColumns as $joinColumn) {
  1732.                     $columns[] = $joinTableName . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1733.                 }
  1734.             } else {
  1735.                 if (! $association['isOwningSide']) {
  1736.                     throw InvalidFindByCall::fromInverseSideUsage(
  1737.                         $this->class->name,
  1738.                         $field
  1739.                     );
  1740.                 }
  1742.                 $className = $association['inherited'] ?? $this->class->name;
  1744.                 foreach ($association['joinColumns'] as $joinColumn) {
  1745.                     $columns[] = $this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1746.                 }
  1747.             }
  1749.             return $columns;
  1750.         }
  1752.         if ($assoc !== null && ! str_contains($field, ' ') && ! str_contains($field, '(')) {
  1753.             // very careless developers could potentially open up this normally hidden api for userland attacks,
  1754.             // therefore checking for spaces and function calls which are not allowed.
  1756.             // found a join column condition, not really a "field"
  1757.             return [$field];
  1758.         }
  1760.         throw UnrecognizedField::byFullyQualifiedName($this->class->name, $field);
  1761.     }
  1763.     /**
  1764.      * Gets the conditional SQL fragment used in the WHERE clause when selecting
  1765.      * entities in this persister.
  1766.      *
  1767.      * Subclasses are supposed to override this method if they intend to change
  1768.      * or alter the criteria by which entities are selected.
  1769.      *
  1770.      * @param AssociationMapping|null $assoc
  1771.      * @psalm-param array<string, mixed> $criteria
  1772.      * @psalm-param array<string, mixed>|null $assoc
  1773.      *
  1774.      * @return string
  1775.      */
  1776.     protected function getSelectConditionSQL(array $criteria, $assoc = null)
  1777.     {
  1778.         $conditions = [];
  1780.         foreach ($criteria as $field => $value) {
  1781.             $conditions[] = $this->getSelectConditionStatementSQL($field, $value, $assoc);
  1782.         }
  1784.         return implode(' AND ', $conditions);
  1785.     }
  1787.     /**
  1788.      * {@inheritDoc}
  1789.      */
  1790.     public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1791.     {
  1792.         $this->switchPersisterContext($offset, $limit);
  1794.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity, $offset, $limit);
  1796.         return $this->loadArrayFromResult($assoc, $stmt);
  1797.     }
  1799.     /**
  1800.      * {@inheritDoc}
  1801.      */
  1802.     public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1803.     {
  1804.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity);
  1806.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1807.     }
  1809.     /**
  1810.      * Builds criteria and execute SQL statement to fetch the one to many entities from.
  1811.      *
  1812.      * @param object $sourceEntity
  1813.      * @psalm-param AssociationMapping $assoc
  1814.      */
  1815.     private function getOneToManyStatement(
  1816.         array $assoc,
  1817.         $sourceEntity,
  1818.         ?int $offset = null,
  1819.         ?int $limit = null
  1820.     ): Result {
  1821.         $this->switchPersisterContext($offset, $limit);
  1823.         $criteria    = [];
  1824.         $parameters  = [];
  1825.         $owningAssoc = $this->class->associationMappings[$assoc['mappedBy']];
  1826.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1827.         $tableAlias  = $this->getSQLTableAlias($owningAssoc['inherited'] ?? $this->class->name);
  1829.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  1830.             if ($sourceClass->containsForeignIdentifier) {
  1831.                 $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1832.                 $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1834.                 if (isset($sourceClass->associationMappings[$field])) {
  1835.                     $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1836.                     $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1837.                 }
  1839.                 $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1840.                 $parameters[]                                   = [
  1841.                     'value' => $value,
  1842.                     'field' => $field,
  1843.                     'class' => $sourceClass,
  1844.                 ];
  1846.                 continue;
  1847.             }
  1849.             $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1850.             $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1852.             $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1853.             $parameters[]                                   = [
  1854.                 'value' => $value,
  1855.                 'field' => $field,
  1856.                 'class' => $sourceClass,
  1857.             ];
  1858.         }
  1860.         $sql              = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1861.         [$params, $types] = $this->expandToManyParameters($parameters);
  1863.         return $this->conn->executeQuery($sql, $params, $types);
  1864.     }
  1866.     /**
  1867.      * {@inheritDoc}
  1868.      */
  1869.     public function expandParameters($criteria)
  1870.     {
  1871.         $params = [];
  1872.         $types  = [];
  1874.         foreach ($criteria as $field => $value) {
  1875.             if ($value === null) {
  1876.                 continue; // skip null values.
  1877.             }
  1879.             $types  = array_merge($types, $this->getTypes($field, $value, $this->class));
  1880.             $params = array_merge($params, $this->getValues($value));
  1881.         }
  1883.         return [$params, $types];
  1884.     }
  1886.     /**
  1887.      * Expands the parameters from the given criteria and use the correct binding types if found,
  1888.      * specialized for OneToMany or ManyToMany associations.
  1889.      *
  1890.      * @param mixed[][] $criteria an array of arrays containing following:
  1891.      *                             - field to which each criterion will be bound
  1892.      *                             - value to be bound
  1893.      *                             - class to which the field belongs to
  1894.      *
  1895.      * @return mixed[][]
  1896.      * @psalm-return array{0: array, 1: list<int|string|null>}
  1897.      */
  1898.     private function expandToManyParameters(array $criteria): array
  1899.     {
  1900.         $params = [];
  1901.         $types  = [];
  1903.         foreach ($criteria as $criterion) {
  1904.             if ($criterion['value'] === null) {
  1905.                 continue; // skip null values.
  1906.             }
  1908.             $types  = array_merge($types, $this->getTypes($criterion['field'], $criterion['value'], $criterion['class']));
  1909.             $params = array_merge($params, $this->getValues($criterion['value']));
  1910.         }
  1912.         return [$params, $types];
  1913.     }
  1915.     /**
  1916.      * Infers field types to be used by parameter type casting.
  1917.      *
  1918.      * @param mixed $value
  1919.      *
  1920.      * @return int[]|null[]|string[]
  1921.      * @psalm-return list<int|string|null>
  1922.      *
  1923.      * @throws QueryException
  1924.      */
  1925.     private function getTypes(string $field, $value, ClassMetadata $class): array
  1926.     {
  1927.         $types = [];
  1929.         switch (true) {
  1930.             case isset($class->fieldMappings[$field]):
  1931.                 $types = array_merge($types, [$class->fieldMappings[$field]['type']]);
  1932.                 break;
  1934.             case isset($class->associationMappings[$field]):
  1935.                 $assoc = $class->associationMappings[$field];
  1936.                 $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1938.                 if (! $assoc['isOwningSide']) {
  1939.                     $assoc = $class->associationMappings[$assoc['mappedBy']];
  1940.                     $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1941.                 }
  1943.                 $columns = $assoc['type'] === ClassMetadata::MANY_TO_MANY
  1944.                     ? $assoc['relationToTargetKeyColumns']
  1945.                     : $assoc['sourceToTargetKeyColumns'];
  1947.                 foreach ($columns as $column) {
  1948.                     $types[] = PersisterHelper::getTypeOfColumn($column, $class, $this->em);
  1949.                 }
  1951.                 break;
  1953.             default:
  1954.                 $types[] = null;
  1955.                 break;
  1956.         }
  1958.         if (is_array($value)) {
  1959.             return array_map(static function ($type) {
  1960.                 $type = Type::getType($type);
  1962.                 return $type->getBindingType() + Connection::ARRAY_PARAM_OFFSET;
  1963.             }, $types);
  1964.         }
  1966.         return $types;
  1967.     }
  1969.     /**
  1970.      * Retrieves the parameters that identifies a value.
  1971.      *
  1972.      * @param mixed $value
  1973.      *
  1974.      * @return mixed[]
  1975.      */
  1976.     private function getValues($value): array
  1977.     {
  1978.         if (is_array($value)) {
  1979.             $newValue = [];
  1981.             foreach ($value as $itemValue) {
  1982.                 $newValue = array_merge($newValue, $this->getValues($itemValue));
  1983.             }
  1985.             return [$newValue];
  1986.         }
  1988.         return $this->getIndividualValue($value);
  1989.     }
  1991.     /**
  1992.      * Retrieves an individual parameter value.
  1993.      *
  1994.      * @param mixed $value
  1995.      *
  1996.      * @psalm-return list<mixed>
  1997.      */
  1998.     private function getIndividualValue($value): array
  1999.     {
  2000.         if (! is_object($value)) {
  2001.             return [$value];
  2002.         }
  2004.         if ($value instanceof BackedEnum) {
  2005.             return [$value->value];
  2006.         }
  2008.         $valueClass = ClassUtils::getClass($value);
  2010.         if ($this->em->getMetadataFactory()->isTransient($valueClass)) {
  2011.             return [$value];
  2012.         }
  2014.         $class = $this->em->getClassMetadata($valueClass);
  2016.         if ($class->isIdentifierComposite) {
  2017.             $newValue = [];
  2019.             foreach ($class->getIdentifierValues($value) as $innerValue) {
  2020.                 $newValue = array_merge($newValue, $this->getValues($innerValue));
  2021.             }
  2023.             return $newValue;
  2024.         }
  2026.         return [$this->em->getUnitOfWork()->getSingleIdentifierValue($value)];
  2027.     }
  2029.     /**
  2030.      * {@inheritDoc}
  2031.      */
  2032.     public function exists($entity, ?Criteria $extraConditions = null)
  2033.     {
  2034.         $criteria = $this->class->getIdentifierValues($entity);
  2036.         if (! $criteria) {
  2037.             return false;
  2038.         }
  2040.         $alias = $this->getSQLTableAlias($this->class->name);
  2042.         $sql = 'SELECT 1 '
  2043.              . $this->getLockTablesSql(LockMode::NONE)
  2044.              . ' WHERE ' . $this->getSelectConditionSQL($criteria);
  2046.         [$params, $types] = $this->expandParameters($criteria);
  2048.         if ($extraConditions !== null) {
  2049.             $sql                             .= ' AND ' . $this->getSelectConditionCriteriaSQL($extraConditions);
  2050.             [$criteriaParams, $criteriaTypes] = $this->expandCriteriaParameters($extraConditions);
  2052.             $params = array_merge($params, $criteriaParams);
  2053.             $types  = array_merge($types, $criteriaTypes);
  2054.         }
  2056.         $filterSql = $this->generateFilterConditionSQL($this->class, $alias);
  2057.         if ($filterSql) {
  2058.             $sql .= ' AND ' . $filterSql;
  2059.         }
  2061.         return (bool) $this->conn->fetchOne($sql, $params, $types);
  2062.     }
  2064.     /**
  2065.      * Generates the appropriate join SQL for the given join column.
  2066.      *
  2067.      * @param array[] $joinColumns The join columns definition of an association.
  2068.      * @psalm-param array<array<string, mixed>> $joinColumns
  2069.      *
  2070.      * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
  2071.      */
  2072.     protected function getJoinSQLForJoinColumns($joinColumns)
  2073.     {
  2074.         // if one of the join columns is nullable, return left join
  2075.         foreach ($joinColumns as $joinColumn) {
  2076.             if (! isset($joinColumn['nullable']) || $joinColumn['nullable']) {
  2077.                 return 'LEFT JOIN';
  2078.             }
  2079.         }
  2081.         return 'INNER JOIN';
  2082.     }
  2084.     /**
  2085.      * @param string $columnName
  2086.      *
  2087.      * @return string
  2088.      */
  2089.     public function getSQLColumnAlias($columnName)
  2090.     {
  2091.         return $this->quoteStrategy->getColumnAlias($columnName, $this->currentPersisterContext->sqlAliasCounter++, $this->platform);
  2092.     }
  2094.     /**
  2095.      * Generates the filter SQL for a given entity and table alias.
  2096.      *
  2097.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  2098.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  2099.      *
  2100.      * @return string The SQL query part to add to a query.
  2101.      */
  2102.     protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
  2103.     {
  2104.         $filterClauses = [];
  2106.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  2107.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  2108.             if ($filterExpr !== '') {
  2109.                 $filterClauses[] = '(' . $filterExpr . ')';
  2110.             }
  2111.         }
  2113.         $sql = implode(' AND ', $filterClauses);
  2115.         return $sql ? '(' . $sql . ')' : ''; // Wrap again to avoid "X or Y and FilterConditionSQL"
  2116.     }
  2118.     /**
  2119.      * Switches persister context according to current query offset/limits
  2120.      *
  2121.      * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
  2122.      *
  2123.      * @param int|null $offset
  2124.      * @param int|null $limit
  2125.      *
  2126.      * @return void
  2127.      */
  2128.     protected function switchPersisterContext($offset, $limit)
  2129.     {
  2130.         if ($offset === null && $limit === null) {
  2131.             $this->currentPersisterContext = $this->noLimitsContext;
  2133.             return;
  2134.         }
  2136.         $this->currentPersisterContext = $this->limitsHandlingContext;
  2137.     }
  2139.     /**
  2140.      * @return string[]
  2141.      * @psalm-return list<string>
  2142.      */
  2143.     protected function getClassIdentifiersTypes(ClassMetadata $class): array
  2144.     {
  2145.         $entityManager = $this->em;
  2147.         return array_map(
  2148.             static function ($fieldName) use ($class, $entityManager): string {
  2149.                 $types = PersisterHelper::getTypeOfField($fieldName, $class, $entityManager);
  2150.                 assert(isset($types[0]));
  2152.                 return $types[0];
  2153.             },
  2154.             $class->identifier
  2155.         );
  2156.     }
  2157. }