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

Open in your IDE?
  1. <?php
  3. /*
  4.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  5.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  6.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  7.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  8.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  9.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  10.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  11.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  12.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  13.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  14.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  15.  *
  16.  * This software consists of voluntary contributions made by many individuals
  17.  * and is licensed under the MIT license. For more information, see
  18.  * <http://www.doctrine-project.org>.
  19.  */
  21. namespace Doctrine\ORM\Persisters\Entity;
  23. use Doctrine\Common\Collections\Criteria;
  24. use Doctrine\Common\Collections\Expr\Comparison;
  25. use Doctrine\Common\Util\ClassUtils;
  26. use Doctrine\DBAL\Connection;
  27. use Doctrine\DBAL\Driver\ResultStatement as DriverStatement;
  28. use Doctrine\DBAL\LockMode;
  29. use Doctrine\DBAL\Platforms\AbstractPlatform;
  30. use Doctrine\DBAL\Types\Type;
  31. use Doctrine\ORM\EntityManagerInterface;
  32. use Doctrine\ORM\Mapping\ClassMetadata;
  33. use Doctrine\ORM\Mapping\MappingException;
  34. use Doctrine\ORM\Mapping\QuoteStrategy;
  35. use Doctrine\ORM\OptimisticLockException;
  36. use Doctrine\ORM\ORMException;
  37. use Doctrine\ORM\PersistentCollection;
  38. use Doctrine\ORM\Persisters\SqlExpressionVisitor;
  39. use Doctrine\ORM\Persisters\SqlValueVisitor;
  40. use Doctrine\ORM\Query;
  41. use Doctrine\ORM\Query\QueryException;
  42. use Doctrine\ORM\UnitOfWork;
  43. use Doctrine\ORM\Utility\IdentifierFlattener;
  44. use Doctrine\ORM\Utility\PersisterHelper;
  46. use function array_combine;
  47. use function array_map;
  48. use function array_merge;
  49. use function array_search;
  50. use function array_unique;
  51. use function array_values;
  52. use function assert;
  53. use function count;
  54. use function get_class;
  55. use function implode;
  56. use function is_array;
  57. use function is_object;
  58. use function reset;
  59. use function spl_object_hash;
  60. use function sprintf;
  61. use function strpos;
  62. use function strtoupper;
  63. use function trim;
  65. /**
  66.  * A BasicEntityPersister maps an entity to a single table in a relational database.
  67.  *
  68.  * A persister is always responsible for a single entity type.
  69.  *
  70.  * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
  71.  * state of entities onto a relational database when the UnitOfWork is committed,
  72.  * as well as for basic querying of entities and their associations (not DQL).
  73.  *
  74.  * The persisting operations that are invoked during a commit of a UnitOfWork to
  75.  * persist the persistent entity state are:
  76.  *
  77.  *   - {@link addInsert} : To schedule an entity for insertion.
  78.  *   - {@link executeInserts} : To execute all scheduled insertions.
  79.  *   - {@link update} : To update the persistent state of an entity.
  80.  *   - {@link delete} : To delete the persistent state of an entity.
  81.  *
  82.  * As can be seen from the above list, insertions are batched and executed all at once
  83.  * for increased efficiency.
  84.  *
  85.  * The querying operations invoked during a UnitOfWork, either through direct find
  86.  * requests or lazy-loading, are the following:
  87.  *
  88.  *   - {@link load} : Loads (the state of) a single, managed entity.
  89.  *   - {@link loadAll} : Loads multiple, managed entities.
  90.  *   - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
  91.  *   - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
  92.  *   - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
  93.  *
  94.  * The BasicEntityPersister implementation provides the default behavior for
  95.  * persisting and querying entities that are mapped to a single database table.
  96.  *
  97.  * Subclasses can be created to provide custom persisting and querying strategies,
  98.  * i.e. spanning multiple tables.
  99.  */
  100. class BasicEntityPersister implements EntityPersister
  101. {
  102.     /** @var array<string,string> */
  103.     private static $comparisonMap = [
  104.         Comparison::EQ          => '= %s',
  105.         Comparison::NEQ         => '!= %s',
  106.         Comparison::GT          => '> %s',
  107.         Comparison::GTE         => '>= %s',
  108.         Comparison::LT          => '< %s',
  109.         Comparison::LTE         => '<= %s',
  110.         Comparison::IN          => 'IN (%s)',
  111.         Comparison::NIN         => 'NOT IN (%s)',
  112.         Comparison::CONTAINS    => 'LIKE %s',
  113.         Comparison::STARTS_WITH => 'LIKE %s',
  114.         Comparison::ENDS_WITH   => 'LIKE %s',
  115.     ];
  117.     /**
  118.      * Metadata object that describes the mapping of the mapped entity class.
  119.      *
  120.      * @var ClassMetadata
  121.      */
  122.     protected $class;
  124.     /**
  125.      * The underlying DBAL Connection of the used EntityManager.
  126.      *
  127.      * @var Connection $conn
  128.      */
  129.     protected $conn;
  131.     /**
  132.      * The database platform.
  133.      *
  134.      * @var AbstractPlatform
  135.      */
  136.     protected $platform;
  138.     /**
  139.      * The EntityManager instance.
  140.      *
  141.      * @var EntityManagerInterface
  142.      */
  143.     protected $em;
  145.     /**
  146.      * Queued inserts.
  147.      *
  148.      * @psalm-var array<string, object>
  149.      */
  150.     protected $queuedInserts = [];
  152.     /**
  153.      * The map of column names to DBAL mapping types of all prepared columns used
  154.      * when INSERTing or UPDATEing an entity.
  155.      *
  156.      * @see prepareInsertData($entity)
  157.      * @see prepareUpdateData($entity)
  158.      *
  159.      * @var mixed[]
  160.      */
  161.     protected $columnTypes = [];
  163.     /**
  164.      * The map of quoted column names.
  165.      *
  166.      * @see prepareInsertData($entity)
  167.      * @see prepareUpdateData($entity)
  168.      *
  169.      * @var mixed[]
  170.      */
  171.     protected $quotedColumns = [];
  173.     /**
  174.      * The INSERT SQL statement used for entities handled by this persister.
  175.      * This SQL is only generated once per request, if at all.
  176.      *
  177.      * @var string
  178.      */
  179.     private $insertSql;
  181.     /**
  182.      * The quote strategy.
  183.      *
  184.      * @var QuoteStrategy
  185.      */
  186.     protected $quoteStrategy;
  188.     /**
  189.      * The IdentifierFlattener used for manipulating identifiers
  190.      *
  191.      * @var IdentifierFlattener
  192.      */
  193.     private $identifierFlattener;
  195.     /** @var CachedPersisterContext */
  196.     protected $currentPersisterContext;
  198.     /** @var CachedPersisterContext */
  199.     private $limitsHandlingContext;
  201.     /** @var CachedPersisterContext */
  202.     private $noLimitsContext;
  204.     /**
  205.      * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
  206.      * and persists instances of the class described by the given ClassMetadata descriptor.
  207.      */
  208.     public function __construct(EntityManagerInterface $em, ClassMetadata $class)
  209.     {
  210.         $this->em                    = $em;
  211.         $this->class                 = $class;
  212.         $this->conn                  = $em->getConnection();
  213.         $this->platform              = $this->conn->getDatabasePlatform();
  214.         $this->quoteStrategy         = $em->getConfiguration()->getQuoteStrategy();
  215.         $this->identifierFlattener   = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
  216.         $this->noLimitsContext       = $this->currentPersisterContext = new CachedPersisterContext(
  217.             $class,
  218.             new Query\ResultSetMapping(),
  219.             false
  220.         );
  221.         $this->limitsHandlingContext = new CachedPersisterContext(
  222.             $class,
  223.             new Query\ResultSetMapping(),
  224.             true
  225.         );
  226.     }
  228.     /**
  229.      * {@inheritdoc}
  230.      */
  231.     public function getClassMetadata()
  232.     {
  233.         return $this->class;
  234.     }
  236.     /**
  237.      * {@inheritdoc}
  238.      */
  239.     public function getResultSetMapping()
  240.     {
  241.         return $this->currentPersisterContext->rsm;
  242.     }
  244.     /**
  245.      * {@inheritdoc}
  246.      */
  247.     public function addInsert($entity)
  248.     {
  249.         $this->queuedInserts[spl_object_hash($entity)] = $entity;
  250.     }
  252.     /**
  253.      * {@inheritdoc}
  254.      */
  255.     public function getInserts()
  256.     {
  257.         return $this->queuedInserts;
  258.     }
  260.     /**
  261.      * {@inheritdoc}
  262.      */
  263.     public function executeInserts()
  264.     {
  265.         if (! $this->queuedInserts) {
  266.             return [];
  267.         }
  269.         $postInsertIds  = [];
  270.         $idGenerator    = $this->class->idGenerator;
  271.         $isPostInsertId = $idGenerator->isPostInsertGenerator();
  273.         $stmt      = $this->conn->prepare($this->getInsertSQL());
  274.         $tableName = $this->class->getTableName();
  276.         foreach ($this->queuedInserts as $entity) {
  277.             $insertData = $this->prepareInsertData($entity);
  279.             if (isset($insertData[$tableName])) {
  280.                 $paramIndex = 1;
  282.                 foreach ($insertData[$tableName] as $column => $value) {
  283.                     $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$column]);
  284.                 }
  285.             }
  287.             $stmt->execute();
  289.             if ($isPostInsertId) {
  290.                 $generatedId     = $idGenerator->generate($this->em, $entity);
  291.                 $id              = [$this->class->identifier[0] => $generatedId];
  292.                 $postInsertIds[] = [
  293.                     'generatedId' => $generatedId,
  294.                     'entity' => $entity,
  295.                 ];
  296.             } else {
  297.                 $id = $this->class->getIdentifierValues($entity);
  298.             }
  300.             if ($this->class->isVersioned) {
  301.                 $this->assignDefaultVersionValue($entity, $id);
  302.             }
  303.         }
  305.         $stmt->closeCursor();
  306.         $this->queuedInserts = [];
  308.         return $postInsertIds;
  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.
  315.      *
  316.      * @param object  $entity
  317.      * @param mixed[] $id
  318.      *
  319.      * @return void
  320.      */
  321.     protected function assignDefaultVersionValue($entity, array $id)
  322.     {
  323.         $value = $this->fetchVersionValue($this->class, $id);
  325.         $this->class->setFieldValue($entity, $this->class->versionField, $value);
  326.     }
  328.     /**
  329.      * Fetches the current version value of a versioned entity.
  330.      *
  331.      * @param ClassMetadata $versionedClass
  332.      * @param mixed[]       $id
  333.      *
  334.      * @return mixed
  335.      */
  336.     protected function fetchVersionValue($versionedClass, array $id)
  337.     {
  338.         $versionField = $versionedClass->versionField;
  339.         $fieldMapping = $versionedClass->fieldMappings[$versionField];
  340.         $tableName    = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
  341.         $identifier   = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
  342.         $columnName   = $this->quoteStrategy->getColumnName($versionField, $versionedClass, $this->platform);
  344.         // FIXME: Order with composite keys might not be correct
  345.         $sql = 'SELECT ' . $columnName
  346.              . ' FROM ' . $tableName
  347.              . ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
  349.         $flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
  351.         $value = $this->conn->fetchColumn(
  352.             $sql,
  353.             array_values($flatId),
  354.             0,
  355.             $this->extractIdentifierTypes($id, $versionedClass)
  356.         );
  358.         return Type::getType($fieldMapping['type'])->convertToPHPValue($value, $this->platform);
  359.     }
  361.     /**
  362.      * @param mixed[] $id
  363.      *
  364.      * @return int[]|null[]|string[]
  365.      * @psalm-return list<int|string|null>
  366.      */
  367.     private function extractIdentifierTypes(array $id, ClassMetadata $versionedClass): array
  368.     {
  369.         $types = [];
  371.         foreach ($id as $field => $value) {
  372.             $types = array_merge($types, $this->getTypes($field, $value, $versionedClass));
  373.         }
  375.         return $types;
  376.     }
  378.     /**
  379.      * {@inheritdoc}
  380.      */
  381.     public function update($entity)
  382.     {
  383.         $tableName  = $this->class->getTableName();
  384.         $updateData = $this->prepareUpdateData($entity);
  386.         if (! isset($updateData[$tableName])) {
  387.             return;
  388.         }
  390.         $data = $updateData[$tableName];
  392.         if (! $data) {
  393.             return;
  394.         }
  396.         $isVersioned     = $this->class->isVersioned;
  397.         $quotedTableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  399.         $this->updateTable($entity, $quotedTableName, $data, $isVersioned);
  401.         if ($isVersioned) {
  402.             $id = $this->class->getIdentifierValues($entity);
  404.             $this->assignDefaultVersionValue($entity, $id);
  405.         }
  406.     }
  408.     /**
  409.      * Performs an UPDATE statement for an entity on a specific table.
  410.      * The UPDATE can optionally be versioned, which requires the entity to have a version field.
  411.      *
  412.      * @param object  $entity          The entity object being updated.
  413.      * @param string  $quotedTableName The quoted name of the table to apply the UPDATE on.
  414.      * @param mixed[] $updateData      The map of columns to update (column => value).
  415.      * @param bool    $versioned       Whether the UPDATE should be versioned.
  416.      *
  417.      * @throws ORMException
  418.      * @throws OptimisticLockException
  419.      */
  420.     final protected function updateTable(
  421.         $entity,
  422.         $quotedTableName,
  423.         array $updateData,
  424.         $versioned = false
  425.     ): void {
  426.         $set    = [];
  427.         $types  = [];
  428.         $params = [];
  430.         foreach ($updateData as $columnName => $value) {
  431.             $placeholder = '?';
  432.             $column      = $columnName;
  434.             switch (true) {
  435.                 case isset($this->class->fieldNames[$columnName]):
  436.                     $fieldName = $this->class->fieldNames[$columnName];
  437.                     $column    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  439.                     if (isset($this->class->fieldMappings[$fieldName]['requireSQLConversion'])) {
  440.                         $type        = Type::getType($this->columnTypes[$columnName]);
  441.                         $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  442.                     }
  444.                     break;
  446.                 case isset($this->quotedColumns[$columnName]):
  447.                     $column = $this->quotedColumns[$columnName];
  449.                     break;
  450.             }
  452.             $params[] = $value;
  453.             $set[]    = $column . ' = ' . $placeholder;
  454.             $types[]  = $this->columnTypes[$columnName];
  455.         }
  457.         $where      = [];
  458.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  460.         foreach ($this->class->identifier as $idField) {
  461.             if (! isset($this->class->associationMappings[$idField])) {
  462.                 $params[] = $identifier[$idField];
  463.                 $types[]  = $this->class->fieldMappings[$idField]['type'];
  464.                 $where[]  = $this->quoteStrategy->getColumnName($idField, $this->class, $this->platform);
  466.                 continue;
  467.             }
  469.             $params[] = $identifier[$idField];
  470.             $where[]  = $this->quoteStrategy->getJoinColumnName(
  471.                 $this->class->associationMappings[$idField]['joinColumns'][0],
  472.                 $this->class,
  473.                 $this->platform
  474.             );
  476.             $targetMapping = $this->em->getClassMetadata($this->class->associationMappings[$idField]['targetEntity']);
  477.             $targetType    = PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping, $this->em);
  479.             if ($targetType === []) {
  480.                 throw ORMException::unrecognizedField($targetMapping->identifier[0]);
  481.             }
  483.             $types[] = reset($targetType);
  484.         }
  486.         if ($versioned) {
  487.             $versionField     = $this->class->versionField;
  488.             $versionFieldType = $this->class->fieldMappings[$versionField]['type'];
  489.             $versionColumn    = $this->quoteStrategy->getColumnName($versionField, $this->class, $this->platform);
  491.             $where[]  = $versionColumn;
  492.             $types[]  = $this->class->fieldMappings[$versionField]['type'];
  493.             $params[] = $this->class->reflFields[$versionField]->getValue($entity);
  495.             switch ($versionFieldType) {
  496.                 case Type::SMALLINT:
  497.                 case Type::INTEGER:
  498.                 case Type::BIGINT:
  499.                     $set[] = $versionColumn . ' = ' . $versionColumn . ' + 1';
  500.                     break;
  502.                 case Type::DATETIME:
  503.                     $set[] = $versionColumn . ' = CURRENT_TIMESTAMP';
  504.                     break;
  505.             }
  506.         }
  508.         $sql = 'UPDATE ' . $quotedTableName
  509.              . ' SET ' . implode(', ', $set)
  510.              . ' WHERE ' . implode(' = ? AND ', $where) . ' = ?';
  512.         $result = $this->conn->executeUpdate($sql, $params, $types);
  514.         if ($versioned && ! $result) {
  515.             throw OptimisticLockException::lockFailed($entity);
  516.         }
  517.     }
  519.     /**
  520.      * @param array<mixed> $identifier
  521.      * @param string[]     $types
  522.      *
  523.      * @todo Add check for platform if it supports foreign keys/cascading.
  524.      */
  525.     protected function deleteJoinTableRecords(array $identifier, array $types): void
  526.     {
  527.         foreach ($this->class->associationMappings as $mapping) {
  528.             if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY) {
  529.                 continue;
  530.             }
  532.             // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
  533.             // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
  534.             $selfReferential = ($mapping['targetEntity'] === $mapping['sourceEntity']);
  535.             $class           = $this->class;
  536.             $association     = $mapping;
  537.             $otherColumns    = [];
  538.             $otherKeys       = [];
  539.             $keys            = [];
  541.             if (! $mapping['isOwningSide']) {
  542.                 $class       = $this->em->getClassMetadata($mapping['targetEntity']);
  543.                 $association = $class->associationMappings[$mapping['mappedBy']];
  544.             }
  546.             $joinColumns = $mapping['isOwningSide']
  547.                 ? $association['joinTable']['joinColumns']
  548.                 : $association['joinTable']['inverseJoinColumns'];
  550.             if ($selfReferential) {
  551.                 $otherColumns = ! $mapping['isOwningSide']
  552.                     ? $association['joinTable']['joinColumns']
  553.                     : $association['joinTable']['inverseJoinColumns'];
  554.             }
  556.             foreach ($joinColumns as $joinColumn) {
  557.                 $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  558.             }
  560.             foreach ($otherColumns as $joinColumn) {
  561.                 $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  562.             }
  564.             if (isset($mapping['isOnDeleteCascade'])) {
  565.                 continue;
  566.             }
  568.             $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  570.             $this->conn->delete($joinTableName, array_combine($keys, $identifier), $types);
  572.             if ($selfReferential) {
  573.                 $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier), $types);
  574.             }
  575.         }
  576.     }
  578.     /**
  579.      * {@inheritdoc}
  580.      */
  581.     public function delete($entity)
  582.     {
  583.         $class      = $this->class;
  584.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  585.         $tableName  = $this->quoteStrategy->getTableName($class, $this->platform);
  586.         $idColumns  = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform);
  587.         $id         = array_combine($idColumns, $identifier);
  588.         $types      = $this->getClassIdentifiersTypes($class);
  590.         $this->deleteJoinTableRecords($identifier, $types);
  592.         return (bool) $this->conn->delete($tableName, $id, $types);
  593.     }
  595.     /**
  596.      * Prepares the changeset of an entity for database insertion (UPDATE).
  597.      *
  598.      * The changeset is obtained from the currently running UnitOfWork.
  599.      *
  600.      * During this preparation the array that is passed as the second parameter is filled with
  601.      * <columnName> => <value> pairs, grouped by table name.
  602.      *
  603.      * Example:
  604.      * <code>
  605.      * array(
  606.      *    'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
  607.      *    'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
  608.      *    ...
  609.      * )
  610.      * </code>
  611.      *
  612.      * @param object $entity The entity for which to prepare the data.
  613.      *
  614.      * @return mixed[][] The prepared data.
  615.      * @psalm-return array<string, array<array-key, mixed|null>>
  616.      */
  617.     protected function prepareUpdateData($entity)
  618.     {
  619.         $versionField = null;
  620.         $result       = [];
  621.         $uow          = $this->em->getUnitOfWork();
  623.         $versioned = $this->class->isVersioned;
  624.         if ($versioned !== false) {
  625.             $versionField = $this->class->versionField;
  626.         }
  628.         foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
  629.             if (isset($versionField) && $versionField === $field) {
  630.                 continue;
  631.             }
  633.             if (isset($this->class->embeddedClasses[$field])) {
  634.                 continue;
  635.             }
  637.             $newVal = $change[1];
  639.             if (! isset($this->class->associationMappings[$field])) {
  640.                 $fieldMapping = $this->class->fieldMappings[$field];
  641.                 $columnName   = $fieldMapping['columnName'];
  643.                 $this->columnTypes[$columnName] = $fieldMapping['type'];
  645.                 $result[$this->getOwningTable($field)][$columnName] = $newVal;
  647.                 continue;
  648.             }
  650.             $assoc = $this->class->associationMappings[$field];
  652.             // Only owning side of x-1 associations can have a FK column.
  653.             if (! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
  654.                 continue;
  655.             }
  657.             if ($newVal !== null) {
  658.                 $oid = spl_object_hash($newVal);
  660.                 if (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal)) {
  661.                     // The associated entity $newVal is not yet persisted, so we must
  662.                     // set $newVal = null, in order to insert a null value and schedule an
  663.                     // extra update on the UnitOfWork.
  664.                     $uow->scheduleExtraUpdate($entity, [$field => [null, $newVal]]);
  666.                     $newVal = null;
  667.                 }
  668.             }
  670.             $newValId = null;
  672.             if ($newVal !== null) {
  673.                 $newValId = $uow->getEntityIdentifier($newVal);
  674.             }
  676.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  677.             $owningTable = $this->getOwningTable($field);
  679.             foreach ($assoc['joinColumns'] as $joinColumn) {
  680.                 $sourceColumn = $joinColumn['name'];
  681.                 $targetColumn = $joinColumn['referencedColumnName'];
  682.                 $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  684.                 $this->quotedColumns[$sourceColumn]  = $quotedColumn;
  685.                 $this->columnTypes[$sourceColumn]    = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
  686.                 $result[$owningTable][$sourceColumn] = $newValId
  687.                     ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
  688.                     : null;
  689.             }
  690.         }
  692.         return $result;
  693.     }
  695.     /**
  696.      * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
  697.      * The changeset of the entity is obtained from the currently running UnitOfWork.
  698.      *
  699.      * The default insert data preparation is the same as for updates.
  700.      *
  701.      * @see prepareUpdateData
  702.      *
  703.      * @param object $entity The entity for which to prepare the data.
  704.      *
  705.      * @return mixed[][] The prepared data for the tables to update.
  706.      * @psalm-return array<string, mixed[]>
  707.      */
  708.     protected function prepareInsertData($entity)
  709.     {
  710.         return $this->prepareUpdateData($entity);
  711.     }
  713.     /**
  714.      * {@inheritdoc}
  715.      */
  716.     public function getOwningTable($fieldName)
  717.     {
  718.         return $this->class->getTableName();
  719.     }
  721.     /**
  722.      * {@inheritdoc}
  723.      */
  724.     public function load(array $criteria, $entity = null, $assoc = null, array $hints = [], $lockMode = null, $limit = null, ?array $orderBy = null)
  725.     {
  726.         $this->switchPersisterContext(null, $limit);
  728.         $sql              = $this->getSelectSQL($criteria, $assoc, $lockMode, $limit, null, $orderBy);
  729.         [$params, $types] = $this->expandParameters($criteria);
  730.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  732.         if ($entity !== null) {
  733.             $hints[Query::HINT_REFRESH]        = true;
  734.             $hints[Query::HINT_REFRESH_ENTITY] = $entity;
  735.         }
  737.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  738.         $entities = $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, $hints);
  740.         return $entities ? $entities[0] : null;
  741.     }
  743.     /**
  744.      * {@inheritdoc}
  745.      */
  746.     public function loadById(array $identifier, $entity = null)
  747.     {
  748.         return $this->load($identifier, $entity);
  749.     }
  751.     /**
  752.      * {@inheritdoc}
  753.      */
  754.     public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
  755.     {
  756.         $foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc['targetEntity']);
  757.         if ($foundEntity !== false) {
  758.             return $foundEntity;
  759.         }
  761.         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  763.         if ($assoc['isOwningSide']) {
  764.             $isInverseSingleValued = $assoc['inversedBy'] && ! $targetClass->isCollectionValuedAssociation($assoc['inversedBy']);
  766.             // Mark inverse side as fetched in the hints, otherwise the UoW would
  767.             // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
  768.             $hints = [];
  770.             if ($isInverseSingleValued) {
  771.                 $hints['fetched']['r'][$assoc['inversedBy']] = true;
  772.             }
  774.             $targetEntity = $this->load($identifier, null, $assoc, $hints);
  776.             // Complete bidirectional association, if necessary
  777.             if ($targetEntity !== null && $isInverseSingleValued) {
  778.                 $targetClass->reflFields[$assoc['inversedBy']]->setValue($targetEntity, $sourceEntity);
  779.             }
  781.             return $targetEntity;
  782.         }
  784.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  785.         $owningAssoc = $targetClass->getAssociationMapping($assoc['mappedBy']);
  787.         $computedIdentifier = [];
  789.         // TRICKY: since the association is specular source and target are flipped
  790.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  791.             if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
  792.                 throw MappingException::joinColumnMustPointToMappedField(
  793.                     $sourceClass->name,
  794.                     $sourceKeyColumn
  795.                 );
  796.             }
  798.             $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  799.                 $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
  800.         }
  802.         $targetEntity = $this->load($computedIdentifier, null, $assoc);
  804.         if ($targetEntity !== null) {
  805.             $targetClass->setFieldValue($targetEntity, $assoc['mappedBy'], $sourceEntity);
  806.         }
  808.         return $targetEntity;
  809.     }
  811.     /**
  812.      * {@inheritdoc}
  813.      */
  814.     public function refresh(array $id, $entity, $lockMode = null)
  815.     {
  816.         $sql              = $this->getSelectSQL($id, null, $lockMode);
  817.         [$params, $types] = $this->expandParameters($id);
  818.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  820.         $hydrator = $this->em->newHydrator(Query::HYDRATE_OBJECT);
  821.         $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
  822.     }
  824.     /**
  825.      * {@inheritDoc}
  826.      */
  827.     public function count($criteria = [])
  828.     {
  829.         $sql = $this->getCountSQL($criteria);
  831.         [$params, $types] = $criteria instanceof Criteria
  832.             ? $this->expandCriteriaParameters($criteria)
  833.             : $this->expandParameters($criteria);
  835.         return (int) $this->conn->executeQuery($sql, $params, $types)->fetchColumn();
  836.     }
  838.     /**
  839.      * {@inheritdoc}
  840.      */
  841.     public function loadCriteria(Criteria $criteria)
  842.     {
  843.         $orderBy = $criteria->getOrderings();
  844.         $limit   = $criteria->getMaxResults();
  845.         $offset  = $criteria->getFirstResult();
  846.         $query   = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  848.         [$params, $types] = $this->expandCriteriaParameters($criteria);
  850.         $stmt     = $this->conn->executeQuery($query, $params, $types);
  851.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  853.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  854.     }
  856.     /**
  857.      * {@inheritdoc}
  858.      */
  859.     public function expandCriteriaParameters(Criteria $criteria)
  860.     {
  861.         $expression = $criteria->getWhereExpression();
  862.         $sqlParams  = [];
  863.         $sqlTypes   = [];
  865.         if ($expression === null) {
  866.             return [$sqlParams, $sqlTypes];
  867.         }
  869.         $valueVisitor = new SqlValueVisitor();
  871.         $valueVisitor->dispatch($expression);
  873.         [$params, $types] = $valueVisitor->getParamsAndTypes();
  875.         foreach ($params as $param) {
  876.             $sqlParams = array_merge($sqlParams, $this->getValues($param));
  877.         }
  879.         foreach ($types as $type) {
  880.             [$field, $value] = $type;
  881.             $sqlTypes        = array_merge($sqlTypes, $this->getTypes($field, $value, $this->class));
  882.         }
  884.         return [$sqlParams, $sqlTypes];
  885.     }
  887.     /**
  888.      * {@inheritdoc}
  889.      */
  890.     public function loadAll(array $criteria = [], ?array $orderBy = null, $limit = null, $offset = null)
  891.     {
  892.         $this->switchPersisterContext($offset, $limit);
  894.         $sql              = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  895.         [$params, $types] = $this->expandParameters($criteria);
  896.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  898.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  900.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  901.     }
  903.     /**
  904.      * {@inheritdoc}
  905.      */
  906.     public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  907.     {
  908.         $this->switchPersisterContext($offset, $limit);
  910.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity, $offset, $limit);
  912.         return $this->loadArrayFromStatement($assoc, $stmt);
  913.     }
  915.     /**
  916.      * Loads an array of entities from a given DBAL statement.
  917.      *
  918.      * @param mixed[] $assoc
  919.      *
  920.      * @return mixed[]
  921.      */
  922.     private function loadArrayFromStatement(array $assoc, DriverStatement $stmt): array
  923.     {
  924.         $rsm   = $this->currentPersisterContext->rsm;
  925.         $hints = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
  927.         if (isset($assoc['indexBy'])) {
  928.             $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  929.             $rsm->addIndexBy('r', $assoc['indexBy']);
  930.         }
  932.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  933.     }
  935.     /**
  936.      * Hydrates a collection from a given DBAL statement.
  937.      *
  938.      * @param mixed[] $assoc
  939.      *
  940.      * @return mixed[]
  941.      */
  942.     private function loadCollectionFromStatement(
  943.         array $assoc,
  944.         DriverStatement $stmt,
  945.         PersistentCollection $coll
  946.     ): array {
  947.         $rsm   = $this->currentPersisterContext->rsm;
  948.         $hints = [
  949.             UnitOfWork::HINT_DEFEREAGERLOAD => true,
  950.             'collection' => $coll,
  951.         ];
  953.         if (isset($assoc['indexBy'])) {
  954.             $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  955.             $rsm->addIndexBy('r', $assoc['indexBy']);
  956.         }
  958.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  959.     }
  961.     /**
  962.      * {@inheritdoc}
  963.      */
  964.     public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  965.     {
  966.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity);
  968.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  969.     }
  971.     /**
  972.      * @param object $sourceEntity
  973.      * @psalm-param array<string, mixed> $assoc
  974.      *
  975.      * @return DriverStatement
  976.      *
  977.      * @throws MappingException
  978.      */
  979.     private function getManyToManyStatement(
  980.         array $assoc,
  981.         $sourceEntity,
  982.         ?int $offset = null,
  983.         ?int $limit = null
  984.     ) {
  985.         $this->switchPersisterContext($offset, $limit);
  987.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  988.         $class       = $sourceClass;
  989.         $association = $assoc;
  990.         $criteria    = [];
  991.         $parameters  = [];
  993.         if (! $assoc['isOwningSide']) {
  994.             $class       = $this->em->getClassMetadata($assoc['targetEntity']);
  995.             $association = $class->associationMappings[$assoc['mappedBy']];
  996.         }
  998.         $joinColumns = $assoc['isOwningSide']
  999.             ? $association['joinTable']['joinColumns']
  1000.             : $association['joinTable']['inverseJoinColumns'];
  1002.         $quotedJoinTable = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1004.         foreach ($joinColumns as $joinColumn) {
  1005.             $sourceKeyColumn = $joinColumn['referencedColumnName'];
  1006.             $quotedKeyColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1008.             switch (true) {
  1009.                 case $sourceClass->containsForeignIdentifier:
  1010.                     $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1011.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1013.                     if (isset($sourceClass->associationMappings[$field])) {
  1014.                         $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1015.                         $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1016.                     }
  1018.                     break;
  1020.                 case isset($sourceClass->fieldNames[$sourceKeyColumn]):
  1021.                     $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1022.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1024.                     break;
  1026.                 default:
  1027.                     throw MappingException::joinColumnMustPointToMappedField(
  1028.                         $sourceClass->name,
  1029.                         $sourceKeyColumn
  1030.                     );
  1031.             }
  1033.             $criteria[$quotedJoinTable . '.' . $quotedKeyColumn] = $value;
  1034.             $parameters[]                                        = [
  1035.                 'value' => $value,
  1036.                 'field' => $field,
  1037.                 'class' => $sourceClass,
  1038.             ];
  1039.         }
  1041.         $sql              = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1042.         [$params, $types] = $this->expandToManyParameters($parameters);
  1044.         return $this->conn->executeQuery($sql, $params, $types);
  1045.     }
  1047.     /**
  1048.      * {@inheritdoc}
  1049.      */
  1050.     public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, ?array $orderBy = null)
  1051.     {
  1052.         $this->switchPersisterContext($offset, $limit);
  1054.         $lockSql    = '';
  1055.         $joinSql    = '';
  1056.         $orderBySql = '';
  1058.         if ($assoc !== null && $assoc['type'] === ClassMetadata::MANY_TO_MANY) {
  1059.             $joinSql = $this->getSelectManyToManyJoinSQL($assoc);
  1060.         }
  1062.         if (isset($assoc['orderBy'])) {
  1063.             $orderBy = $assoc['orderBy'];
  1064.         }
  1066.         if ($orderBy) {
  1067.             $orderBySql = $this->getOrderBySQL($orderBy, $this->getSQLTableAlias($this->class->name));
  1068.         }
  1070.         $conditionSql = $criteria instanceof Criteria
  1071.             ? $this->getSelectConditionCriteriaSQL($criteria)
  1072.             : $this->getSelectConditionSQL($criteria, $assoc);
  1074.         switch ($lockMode) {
  1075.             case LockMode::PESSIMISTIC_READ:
  1076.                 $lockSql = ' ' . $this->platform->getReadLockSQL();
  1077.                 break;
  1079.             case LockMode::PESSIMISTIC_WRITE:
  1080.                 $lockSql = ' ' . $this->platform->getWriteLockSQL();
  1081.                 break;
  1082.         }
  1084.         $columnList = $this->getSelectColumnsSQL();
  1085.         $tableAlias = $this->getSQLTableAlias($this->class->name);
  1086.         $filterSql  = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1087.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1089.         if ($filterSql !== '') {
  1090.             $conditionSql = $conditionSql
  1091.                 ? $conditionSql . ' AND ' . $filterSql
  1092.                 : $filterSql;
  1093.         }
  1095.         $select = 'SELECT ' . $columnList;
  1096.         $from   = ' FROM ' . $tableName . ' ' . $tableAlias;
  1097.         $join   = $this->currentPersisterContext->selectJoinSql . $joinSql;
  1098.         $where  = ($conditionSql ? ' WHERE ' . $conditionSql : '');
  1099.         $lock   = $this->platform->appendLockHint($from, $lockMode);
  1100.         $query  = $select
  1101.             . $lock
  1102.             . $join
  1103.             . $where
  1104.             . $orderBySql;
  1106.         return $this->platform->modifyLimitQuery($query, $limit, $offset) . $lockSql;
  1107.     }
  1109.     /**
  1110.      * {@inheritDoc}
  1111.      */
  1112.     public function getCountSQL($criteria = [])
  1113.     {
  1114.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1115.         $tableAlias = $this->getSQLTableAlias($this->class->name);
  1117.         $conditionSql = $criteria instanceof Criteria
  1118.             ? $this->getSelectConditionCriteriaSQL($criteria)
  1119.             : $this->getSelectConditionSQL($criteria);
  1121.         $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1123.         if ($filterSql !== '') {
  1124.             $conditionSql = $conditionSql
  1125.                 ? $conditionSql . ' AND ' . $filterSql
  1126.                 : $filterSql;
  1127.         }
  1129.         return 'SELECT COUNT(*) '
  1130.             . 'FROM ' . $tableName . ' ' . $tableAlias
  1131.             . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
  1132.     }
  1134.     /**
  1135.      * Gets the ORDER BY SQL snippet for ordered collections.
  1136.      *
  1137.      * @psalm-param array<string, string> $orderBy
  1138.      *
  1139.      * @throws ORMException
  1140.      */
  1141.     final protected function getOrderBySQL(array $orderBy, string $baseTableAlias): string
  1142.     {
  1143.         $orderByList = [];
  1145.         foreach ($orderBy as $fieldName => $orientation) {
  1146.             $orientation = strtoupper(trim($orientation));
  1148.             if ($orientation !== 'ASC' && $orientation !== 'DESC') {
  1149.                 throw ORMException::invalidOrientation($this->class->name, $fieldName);
  1150.             }
  1152.             if (isset($this->class->fieldMappings[$fieldName])) {
  1153.                 $tableAlias = isset($this->class->fieldMappings[$fieldName]['inherited'])
  1154.                     ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
  1155.                     : $baseTableAlias;
  1157.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  1158.                 $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1160.                 continue;
  1161.             }
  1163.             if (isset($this->class->associationMappings[$fieldName])) {
  1164.                 if (! $this->class->associationMappings[$fieldName]['isOwningSide']) {
  1165.                     throw ORMException::invalidFindByInverseAssociation($this->class->name, $fieldName);
  1166.                 }
  1168.                 $tableAlias = isset($this->class->associationMappings[$fieldName]['inherited'])
  1169.                     ? $this->getSQLTableAlias($this->class->associationMappings[$fieldName]['inherited'])
  1170.                     : $baseTableAlias;
  1172.                 foreach ($this->class->associationMappings[$fieldName]['joinColumns'] as $joinColumn) {
  1173.                     $columnName    = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1174.                     $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1175.                 }
  1177.                 continue;
  1178.             }
  1180.             throw ORMException::unrecognizedField($fieldName);
  1181.         }
  1183.         return ' ORDER BY ' . implode(', ', $orderByList);
  1184.     }
  1186.     /**
  1187.      * Gets the SQL fragment with the list of columns to select when querying for
  1188.      * an entity in this persister.
  1189.      *
  1190.      * Subclasses should override this method to alter or change the select column
  1191.      * list SQL fragment. Note that in the implementation of BasicEntityPersister
  1192.      * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
  1193.      * Subclasses may or may not do the same.
  1194.      *
  1195.      * @return string The SQL fragment.
  1196.      */
  1197.     protected function getSelectColumnsSQL()
  1198.     {
  1199.         if ($this->currentPersisterContext->selectColumnListSql !== null) {
  1200.             return $this->currentPersisterContext->selectColumnListSql;
  1201.         }
  1203.         $columnList = [];
  1204.         $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r'); // r for root
  1206.         // Add regular columns to select list
  1207.         foreach ($this->class->fieldNames as $field) {
  1208.             $columnList[] = $this->getSelectColumnSQL($field, $this->class);
  1209.         }
  1211.         $this->currentPersisterContext->selectJoinSql = '';
  1212.         $eagerAliasCounter                            = 0;
  1214.         foreach ($this->class->associationMappings as $assocField => $assoc) {
  1215.             $assocColumnSQL = $this->getSelectColumnAssociationSQL($assocField, $assoc, $this->class);
  1217.             if ($assocColumnSQL) {
  1218.                 $columnList[] = $assocColumnSQL;
  1219.             }
  1221.             $isAssocToOneInverseSide = $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
  1222.             $isAssocFromOneEager     = $assoc['type'] !== ClassMetadata::MANY_TO_MANY && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
  1224.             if (! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
  1225.                 continue;
  1226.             }
  1228.             if ((($assoc['type'] & ClassMetadata::TO_MANY) > 0) && $this->currentPersisterContext->handlesLimits) {
  1229.                 continue;
  1230.             }
  1232.             $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1234.             if ($eagerEntity->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  1235.                 continue; // now this is why you shouldn't use inheritance
  1236.             }
  1238.             $assocAlias = 'e' . ($eagerAliasCounter++);
  1239.             $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc['targetEntity'], $assocAlias, 'r', $assocField);
  1241.             foreach ($eagerEntity->fieldNames as $field) {
  1242.                 $columnList[] = $this->getSelectColumnSQL($field, $eagerEntity, $assocAlias);
  1243.             }
  1245.             foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
  1246.                 $eagerAssocColumnSQL = $this->getSelectColumnAssociationSQL(
  1247.                     $eagerAssocField,
  1248.                     $eagerAssoc,
  1249.                     $eagerEntity,
  1250.                     $assocAlias
  1251.                 );
  1253.                 if ($eagerAssocColumnSQL) {
  1254.                     $columnList[] = $eagerAssocColumnSQL;
  1255.                 }
  1256.             }
  1258.             $association   = $assoc;
  1259.             $joinCondition = [];
  1261.             if (isset($assoc['indexBy'])) {
  1262.                 $this->currentPersisterContext->rsm->addIndexBy($assocAlias, $assoc['indexBy']);
  1263.             }
  1265.             if (! $assoc['isOwningSide']) {
  1266.                 $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1267.                 $association = $eagerEntity->getAssociationMapping($assoc['mappedBy']);
  1268.             }
  1270.             $joinTableAlias = $this->getSQLTableAlias($eagerEntity->name, $assocAlias);
  1271.             $joinTableName  = $this->quoteStrategy->getTableName($eagerEntity, $this->platform);
  1273.             if ($assoc['isOwningSide']) {
  1274.                 $tableAlias                                    = $this->getSQLTableAlias($association['targetEntity'], $assocAlias);
  1275.                 $this->currentPersisterContext->selectJoinSql .= ' ' . $this->getJoinSQLForJoinColumns($association['joinColumns']);
  1277.                 foreach ($association['joinColumns'] as $joinColumn) {
  1278.                     $sourceCol       = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1279.                     $targetCol       = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1280.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'])
  1281.                                         . '.' . $sourceCol . ' = ' . $tableAlias . '.' . $targetCol;
  1282.                 }
  1284.                 // Add filter SQL
  1285.                 $filterSql = $this->generateFilterConditionSQL($eagerEntity, $tableAlias);
  1286.                 if ($filterSql) {
  1287.                     $joinCondition[] = $filterSql;
  1288.                 }
  1289.             } else {
  1290.                 $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
  1292.                 foreach ($association['joinColumns'] as $joinColumn) {
  1293.                     $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1294.                     $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1296.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'], $assocAlias) . '.' . $sourceCol . ' = '
  1297.                         . $this->getSQLTableAlias($association['targetEntity']) . '.' . $targetCol;
  1298.                 }
  1299.             }
  1301.             $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';
  1302.             $this->currentPersisterContext->selectJoinSql .= implode(' AND ', $joinCondition);
  1303.         }
  1305.         $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
  1307.         return $this->currentPersisterContext->selectColumnListSql;
  1308.     }
  1310.     /**
  1311.      * Gets the SQL join fragment used when selecting entities from an association.
  1312.      *
  1313.      * @param string  $field
  1314.      * @param mixed[] $assoc
  1315.      * @param string  $alias
  1316.      *
  1317.      * @return string
  1318.      */
  1319.     protected function getSelectColumnAssociationSQL($field, $assoc, ClassMetadata $class, $alias = 'r')
  1320.     {
  1321.         if (! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)) {
  1322.             return '';
  1323.         }
  1325.         $columnList    = [];
  1326.         $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
  1327.         $isIdentifier  = isset($assoc['id']) && $assoc['id'] === true;
  1328.         $sqlTableAlias = $this->getSQLTableAlias($class->name, ($alias === 'r' ? '' : $alias));
  1330.         foreach ($assoc['joinColumns'] as $joinColumn) {
  1331.             $quotedColumn     = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1332.             $resultColumnName = $this->getSQLColumnAlias($joinColumn['name']);
  1333.             $type             = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  1335.             $this->currentPersisterContext->rsm->addMetaResult($alias, $resultColumnName, $joinColumn['name'], $isIdentifier, $type);
  1337.             $columnList[] = sprintf('%s.%s AS %s', $sqlTableAlias, $quotedColumn, $resultColumnName);
  1338.         }
  1340.         return implode(', ', $columnList);
  1341.     }
  1343.     /**
  1344.      * Gets the SQL join fragment used when selecting entities from a
  1345.      * many-to-many association.
  1346.      *
  1347.      * @psalm-param array<string, mixed> $manyToMany
  1348.      *
  1349.      * @return string
  1350.      */
  1351.     protected function getSelectManyToManyJoinSQL(array $manyToMany)
  1352.     {
  1353.         $conditions       = [];
  1354.         $association      = $manyToMany;
  1355.         $sourceTableAlias = $this->getSQLTableAlias($this->class->name);
  1357.         if (! $manyToMany['isOwningSide']) {
  1358.             $targetEntity = $this->em->getClassMetadata($manyToMany['targetEntity']);
  1359.             $association  = $targetEntity->associationMappings[$manyToMany['mappedBy']];
  1360.         }
  1362.         $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  1363.         $joinColumns   = $manyToMany['isOwningSide']
  1364.             ? $association['joinTable']['inverseJoinColumns']
  1365.             : $association['joinTable']['joinColumns'];
  1367.         foreach ($joinColumns as $joinColumn) {
  1368.             $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1369.             $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1370.             $conditions[]       = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableName . '.' . $quotedSourceColumn;
  1371.         }
  1373.         return ' INNER JOIN ' . $joinTableName . ' ON ' . implode(' AND ', $conditions);
  1374.     }
  1376.     /**
  1377.      * {@inheritdoc}
  1378.      */
  1379.     public function getInsertSQL()
  1380.     {
  1381.         if ($this->insertSql !== null) {
  1382.             return $this->insertSql;
  1383.         }
  1385.         $columns   = $this->getInsertColumnList();
  1386.         $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1388.         if (empty($columns)) {
  1389.             $identityColumn  = $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class, $this->platform);
  1390.             $this->insertSql = $this->platform->getEmptyIdentityInsertSQL($tableName, $identityColumn);
  1392.             return $this->insertSql;
  1393.         }
  1395.         $values  = [];
  1396.         $columns = array_unique($columns);
  1398.         foreach ($columns as $column) {
  1399.             $placeholder = '?';
  1401.             if (
  1402.                 isset($this->class->fieldNames[$column])
  1403.                 && isset($this->columnTypes[$this->class->fieldNames[$column]])
  1404.                 && isset($this->class->fieldMappings[$this->class->fieldNames[$column]]['requireSQLConversion'])
  1405.             ) {
  1406.                 $type        = Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
  1407.                 $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  1408.             }
  1410.             $values[] = $placeholder;
  1411.         }
  1413.         $columns = implode(', ', $columns);
  1414.         $values  = implode(', ', $values);
  1416.         $this->insertSql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tableName, $columns, $values);
  1418.         return $this->insertSql;
  1419.     }
  1421.     /**
  1422.      * Gets the list of columns to put in the INSERT SQL statement.
  1423.      *
  1424.      * Subclasses should override this method to alter or change the list of
  1425.      * columns placed in the INSERT statements used by the persister.
  1426.      *
  1427.      * @return string[] The list of columns.
  1428.      * @psalm-return list<string>
  1429.      */
  1430.     protected function getInsertColumnList()
  1431.     {
  1432.         $columns = [];
  1434.         foreach ($this->class->reflFields as $name => $field) {
  1435.             if ($this->class->isVersioned && $this->class->versionField === $name) {
  1436.                 continue;
  1437.             }
  1439.             if (isset($this->class->embeddedClasses[$name])) {
  1440.                 continue;
  1441.             }
  1443.             if (isset($this->class->associationMappings[$name])) {
  1444.                 $assoc = $this->class->associationMappings[$name];
  1446.                 if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  1447.                     foreach ($assoc['joinColumns'] as $joinColumn) {
  1448.                         $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1449.                     }
  1450.                 }
  1452.                 continue;
  1453.             }
  1455.             if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] !== $name) {
  1456.                 $columns[]                = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
  1457.                 $this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
  1458.             }
  1459.         }
  1461.         return $columns;
  1462.     }
  1464.     /**
  1465.      * Gets the SQL snippet of a qualified column name for the given field name.
  1466.      *
  1467.      * @param string        $field The field name.
  1468.      * @param ClassMetadata $class The class that declares this field. The table this class is
  1469.      *                             mapped to must own the column for the given field.
  1470.      * @param string        $alias
  1471.      *
  1472.      * @return string
  1473.      */
  1474.     protected function getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r')
  1475.     {
  1476.         $root         = $alias === 'r' ? '' : $alias;
  1477.         $tableAlias   = $this->getSQLTableAlias($class->name, $root);
  1478.         $fieldMapping = $class->fieldMappings[$field];
  1479.         $sql          = sprintf('%s.%s', $tableAlias, $this->quoteStrategy->getColumnName($field, $class, $this->platform));
  1480.         $columnAlias  = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1482.         $this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field);
  1484.         if (isset($fieldMapping['requireSQLConversion'])) {
  1485.             $type = Type::getType($fieldMapping['type']);
  1486.             $sql  = $type->convertToPHPValueSQL($sql, $this->platform);
  1487.         }
  1489.         return $sql . ' AS ' . $columnAlias;
  1490.     }
  1492.     /**
  1493.      * Gets the SQL table alias for the given class name.
  1494.      *
  1495.      * @param string $className
  1496.      * @param string $assocName
  1497.      *
  1498.      * @return string The SQL table alias.
  1499.      *
  1500.      * @todo Reconsider. Binding table aliases to class names is not such a good idea.
  1501.      */
  1502.     protected function getSQLTableAlias($className, $assocName = '')
  1503.     {
  1504.         if ($assocName) {
  1505.             $className .= '#' . $assocName;
  1506.         }
  1508.         if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
  1509.             return $this->currentPersisterContext->sqlTableAliases[$className];
  1510.         }
  1512.         $tableAlias = 't' . $this->currentPersisterContext->sqlAliasCounter++;
  1514.         $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
  1516.         return $tableAlias;
  1517.     }
  1519.     /**
  1520.      * {@inheritdoc}
  1521.      */
  1522.     public function lock(array $criteria, $lockMode)
  1523.     {
  1524.         $lockSql      = '';
  1525.         $conditionSql = $this->getSelectConditionSQL($criteria);
  1527.         switch ($lockMode) {
  1528.             case LockMode::PESSIMISTIC_READ:
  1529.                 $lockSql = $this->platform->getReadLockSQL();
  1531.                 break;
  1532.             case LockMode::PESSIMISTIC_WRITE:
  1533.                 $lockSql = $this->platform->getWriteLockSQL();
  1534.                 break;
  1535.         }
  1537.         $lock  = $this->getLockTablesSql($lockMode);
  1538.         $where = ($conditionSql ? ' WHERE ' . $conditionSql : '') . ' ';
  1539.         $sql   = 'SELECT 1 '
  1540.              . $lock
  1541.              . $where
  1542.              . $lockSql;
  1544.         [$params, $types] = $this->expandParameters($criteria);
  1546.         $this->conn->executeQuery($sql, $params, $types);
  1547.     }
  1549.     /**
  1550.      * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
  1551.      *
  1552.      * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants.
  1553.      *
  1554.      * @return string
  1555.      */
  1556.     protected function getLockTablesSql($lockMode)
  1557.     {
  1558.         return $this->platform->appendLockHint(
  1559.             'FROM '
  1560.             . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
  1561.             . $this->getSQLTableAlias($this->class->name),
  1562.             $lockMode
  1563.         );
  1564.     }
  1566.     /**
  1567.      * Gets the Select Where Condition from a Criteria object.
  1568.      *
  1569.      * @return string
  1570.      */
  1571.     protected function getSelectConditionCriteriaSQL(Criteria $criteria)
  1572.     {
  1573.         $expression = $criteria->getWhereExpression();
  1575.         if ($expression === null) {
  1576.             return '';
  1577.         }
  1579.         $visitor = new SqlExpressionVisitor($this, $this->class);
  1581.         return $visitor->dispatch($expression);
  1582.     }
  1584.     /**
  1585.      * {@inheritdoc}
  1586.      */
  1587.     public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
  1588.     {
  1589.         $selectedColumns = [];
  1590.         $columns         = $this->getSelectConditionStatementColumnSQL($field, $assoc);
  1592.         if (count($columns) > 1 && $comparison === Comparison::IN) {
  1593.             /*
  1594.              *  @todo try to support multi-column IN expressions.
  1595.              *  Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
  1596.              */
  1597.             throw ORMException::cantUseInOperatorOnCompositeKeys();
  1598.         }
  1600.         foreach ($columns as $column) {
  1601.             $placeholder = '?';
  1603.             if (isset($this->class->fieldMappings[$field]['requireSQLConversion'])) {
  1604.                 $type        = Type::getType($this->class->fieldMappings[$field]['type']);
  1605.                 $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->platform);
  1606.             }
  1608.             if ($comparison !== null) {
  1609.                 // special case null value handling
  1610.                 if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && $value === null) {
  1611.                     $selectedColumns[] = $column . ' IS NULL';
  1613.                     continue;
  1614.                 }
  1616.                 if ($comparison === Comparison::NEQ && $value === null) {
  1617.                     $selectedColumns[] = $column . ' IS NOT NULL';
  1619.                     continue;
  1620.                 }
  1622.                 $selectedColumns[] = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
  1624.                 continue;
  1625.             }
  1627.             if (is_array($value)) {
  1628.                 $in = sprintf('%s IN (%s)', $column, $placeholder);
  1630.                 if (array_search(null, $value, true) !== false) {
  1631.                     $selectedColumns[] = sprintf('(%s OR %s IS NULL)', $in, $column);
  1633.                     continue;
  1634.                 }
  1636.                 $selectedColumns[] = $in;
  1638.                 continue;
  1639.             }
  1641.             if ($value === null) {
  1642.                 $selectedColumns[] = sprintf('%s IS NULL', $column);
  1644.                 continue;
  1645.             }
  1647.             $selectedColumns[] = sprintf('%s = %s', $column, $placeholder);
  1648.         }
  1650.         return implode(' AND ', $selectedColumns);
  1651.     }
  1653.     /**
  1654.      * Builds the left-hand-side of a where condition statement.
  1655.      *
  1656.      * @psalm-param array<string, mixed>|null $assoc
  1657.      *
  1658.      * @return string[]
  1659.      * @psalm-return list<string>
  1660.      *
  1661.      * @throws ORMException
  1662.      */
  1663.     private function getSelectConditionStatementColumnSQL(
  1664.         string $field,
  1665.         ?array $assoc = null
  1666.     ): array {
  1667.         if (isset($this->class->fieldMappings[$field])) {
  1668.             $className = $this->class->fieldMappings[$field]['inherited'] ?? $this->class->name;
  1670.             return [$this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getColumnName($field, $this->class, $this->platform)];
  1671.         }
  1673.         if (isset($this->class->associationMappings[$field])) {
  1674.             $association = $this->class->associationMappings[$field];
  1675.             // Many-To-Many requires join table check for joinColumn
  1676.             $columns = [];
  1677.             $class   = $this->class;
  1679.             if ($association['type'] === ClassMetadata::MANY_TO_MANY) {
  1680.                 if (! $association['isOwningSide']) {
  1681.                     $association = $assoc;
  1682.                 }
  1684.                 $joinTableName = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1685.                 $joinColumns   = $assoc['isOwningSide']
  1686.                     ? $association['joinTable']['joinColumns']
  1687.                     : $association['joinTable']['inverseJoinColumns'];
  1689.                 foreach ($joinColumns as $joinColumn) {
  1690.                     $columns[] = $joinTableName . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1691.                 }
  1692.             } else {
  1693.                 if (! $association['isOwningSide']) {
  1694.                     throw ORMException::invalidFindByInverseAssociation($this->class->name, $field);
  1695.                 }
  1697.                 $className = $association['inherited'] ?? $this->class->name;
  1699.                 foreach ($association['joinColumns'] as $joinColumn) {
  1700.                     $columns[] = $this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1701.                 }
  1702.             }
  1704.             return $columns;
  1705.         }
  1707.         if ($assoc !== null && strpos($field, ' ') === false && strpos($field, '(') === false) {
  1708.             // very careless developers could potentially open up this normally hidden api for userland attacks,
  1709.             // therefore checking for spaces and function calls which are not allowed.
  1711.             // found a join column condition, not really a "field"
  1712.             return [$field];
  1713.         }
  1715.         throw ORMException::unrecognizedField($field);
  1716.     }
  1718.     /**
  1719.      * Gets the conditional SQL fragment used in the WHERE clause when selecting
  1720.      * entities in this persister.
  1721.      *
  1722.      * Subclasses are supposed to override this method if they intend to change
  1723.      * or alter the criteria by which entities are selected.
  1724.      *
  1725.      * @param mixed[]|null $assoc
  1726.      * @psalm-param array<string, mixed> $criteria
  1727.      * @psalm-param array<string, mixed>|null $assoc
  1728.      *
  1729.      * @return string
  1730.      */
  1731.     protected function getSelectConditionSQL(array $criteria, $assoc = null)
  1732.     {
  1733.         $conditions = [];
  1735.         foreach ($criteria as $field => $value) {
  1736.             $conditions[] = $this->getSelectConditionStatementSQL($field, $value, $assoc);
  1737.         }
  1739.         return implode(' AND ', $conditions);
  1740.     }
  1742.     /**
  1743.      * {@inheritdoc}
  1744.      */
  1745.     public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1746.     {
  1747.         $this->switchPersisterContext($offset, $limit);
  1749.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity, $offset, $limit);
  1751.         return $this->loadArrayFromStatement($assoc, $stmt);
  1752.     }
  1754.     /**
  1755.      * {@inheritdoc}
  1756.      */
  1757.     public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1758.     {
  1759.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity);
  1761.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1762.     }
  1764.     /**
  1765.      * Builds criteria and execute SQL statement to fetch the one to many entities from.
  1766.      *
  1767.      * @param object $sourceEntity
  1768.      * @psalm-param array<string, mixed> $assoc
  1769.      */
  1770.     private function getOneToManyStatement(
  1771.         array $assoc,
  1772.         $sourceEntity,
  1773.         ?int $offset = null,
  1774.         ?int $limit = null
  1775.     ): DriverStatement {
  1776.         $this->switchPersisterContext($offset, $limit);
  1778.         $criteria    = [];
  1779.         $parameters  = [];
  1780.         $owningAssoc = $this->class->associationMappings[$assoc['mappedBy']];
  1781.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1782.         $tableAlias  = $this->getSQLTableAlias($owningAssoc['inherited'] ?? $this->class->name);
  1784.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  1785.             if ($sourceClass->containsForeignIdentifier) {
  1786.                 $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1787.                 $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1789.                 if (isset($sourceClass->associationMappings[$field])) {
  1790.                     $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1791.                     $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1792.                 }
  1794.                 $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1795.                 $parameters[]                                   = [
  1796.                     'value' => $value,
  1797.                     'field' => $field,
  1798.                     'class' => $sourceClass,
  1799.                 ];
  1801.                 continue;
  1802.             }
  1804.             $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1805.             $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1807.             $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1808.             $parameters[]                                   = [
  1809.                 'value' => $value,
  1810.                 'field' => $field,
  1811.                 'class' => $sourceClass,
  1812.             ];
  1813.         }
  1815.         $sql              = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1816.         [$params, $types] = $this->expandToManyParameters($parameters);
  1818.         return $this->conn->executeQuery($sql, $params, $types);
  1819.     }
  1821.     /**
  1822.      * {@inheritdoc}
  1823.      */
  1824.     public function expandParameters($criteria)
  1825.     {
  1826.         $params = [];
  1827.         $types  = [];
  1829.         foreach ($criteria as $field => $value) {
  1830.             if ($value === null) {
  1831.                 continue; // skip null values.
  1832.             }
  1834.             $types  = array_merge($types, $this->getTypes($field, $value, $this->class));
  1835.             $params = array_merge($params, $this->getValues($value));
  1836.         }
  1838.         return [$params, $types];
  1839.     }
  1841.     /**
  1842.      * Expands the parameters from the given criteria and use the correct binding types if found,
  1843.      * specialized for OneToMany or ManyToMany associations.
  1844.      *
  1845.      * @param mixed[][] $criteria an array of arrays containing following:
  1846.      *                             - field to which each criterion will be bound
  1847.      *                             - value to be bound
  1848.      *                             - class to which the field belongs to
  1849.      *
  1850.      * @return mixed[][]
  1851.      * @psalm-return array{0: array, 1: list<int|string|null>}
  1852.      */
  1853.     private function expandToManyParameters(array $criteria): array
  1854.     {
  1855.         $params = [];
  1856.         $types  = [];
  1858.         foreach ($criteria as $criterion) {
  1859.             if ($criterion['value'] === null) {
  1860.                 continue; // skip null values.
  1861.             }
  1863.             $types  = array_merge($types, $this->getTypes($criterion['field'], $criterion['value'], $criterion['class']));
  1864.             $params = array_merge($params, $this->getValues($criterion['value']));
  1865.         }
  1867.         return [$params, $types];
  1868.     }
  1870.     /**
  1871.      * Infers field types to be used by parameter type casting.
  1872.      *
  1873.      * @param mixed $value
  1874.      *
  1875.      * @return int[]|null[]|string[]
  1876.      * @psalm-return list<int|string|null>
  1877.      *
  1878.      * @throws QueryException
  1879.      */
  1880.     private function getTypes(string $field, $value, ClassMetadata $class): array
  1881.     {
  1882.         $types = [];
  1884.         switch (true) {
  1885.             case isset($class->fieldMappings[$field]):
  1886.                 $types = array_merge($types, [$class->fieldMappings[$field]['type']]);
  1887.                 break;
  1889.             case isset($class->associationMappings[$field]):
  1890.                 $assoc = $class->associationMappings[$field];
  1891.                 $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1893.                 if (! $assoc['isOwningSide']) {
  1894.                     $assoc = $class->associationMappings[$assoc['mappedBy']];
  1895.                     $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1896.                 }
  1898.                 $columns = $assoc['type'] === ClassMetadata::MANY_TO_MANY
  1899.                     ? $assoc['relationToTargetKeyColumns']
  1900.                     : $assoc['sourceToTargetKeyColumns'];
  1902.                 foreach ($columns as $column) {
  1903.                     $types[] = PersisterHelper::getTypeOfColumn($column, $class, $this->em);
  1904.                 }
  1906.                 break;
  1908.             default:
  1909.                 $types[] = null;
  1910.                 break;
  1911.         }
  1913.         if (is_array($value)) {
  1914.             return array_map(static function ($type) {
  1915.                 $type = Type::getType($type);
  1917.                 return $type->getBindingType() + Connection::ARRAY_PARAM_OFFSET;
  1918.             }, $types);
  1919.         }
  1921.         return $types;
  1922.     }
  1924.     /**
  1925.      * Retrieves the parameters that identifies a value.
  1926.      *
  1927.      * @param mixed $value
  1928.      *
  1929.      * @return mixed[]
  1930.      */
  1931.     private function getValues($value): array
  1932.     {
  1933.         if (is_array($value)) {
  1934.             $newValue = [];
  1936.             foreach ($value as $itemValue) {
  1937.                 $newValue = array_merge($newValue, $this->getValues($itemValue));
  1938.             }
  1940.             return [$newValue];
  1941.         }
  1943.         if (is_object($value) && $this->em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($value))) {
  1944.             $class = $this->em->getClassMetadata(get_class($value));
  1945.             if ($class->isIdentifierComposite) {
  1946.                 $newValue = [];
  1948.                 foreach ($class->getIdentifierValues($value) as $innerValue) {
  1949.                     $newValue = array_merge($newValue, $this->getValues($innerValue));
  1950.                 }
  1952.                 return $newValue;
  1953.             }
  1954.         }
  1956.         return [$this->getIndividualValue($value)];
  1957.     }
  1959.     /**
  1960.      * Retrieves an individual parameter value.
  1961.      *
  1962.      * @param mixed $value
  1963.      *
  1964.      * @return mixed
  1965.      */
  1966.     private function getIndividualValue($value)
  1967.     {
  1968.         if (! is_object($value) || ! $this->em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($value))) {
  1969.             return $value;
  1970.         }
  1972.         return $this->em->getUnitOfWork()->getSingleIdentifierValue($value);
  1973.     }
  1975.     /**
  1976.      * {@inheritdoc}
  1977.      */
  1978.     public function exists($entity, ?Criteria $extraConditions = null)
  1979.     {
  1980.         $criteria = $this->class->getIdentifierValues($entity);
  1982.         if (! $criteria) {
  1983.             return false;
  1984.         }
  1986.         $alias = $this->getSQLTableAlias($this->class->name);
  1988.         $sql = 'SELECT 1 '
  1989.              . $this->getLockTablesSql(null)
  1990.              . ' WHERE ' . $this->getSelectConditionSQL($criteria);
  1992.         [$params, $types] = $this->expandParameters($criteria);
  1994.         if ($extraConditions !== null) {
  1995.             $sql                             .= ' AND ' . $this->getSelectConditionCriteriaSQL($extraConditions);
  1996.             [$criteriaParams, $criteriaTypes] = $this->expandCriteriaParameters($extraConditions);
  1998.             $params = array_merge($params, $criteriaParams);
  1999.             $types  = array_merge($types, $criteriaTypes);
  2000.         }
  2002.         $filterSql = $this->generateFilterConditionSQL($this->class, $alias);
  2003.         if ($filterSql) {
  2004.             $sql .= ' AND ' . $filterSql;
  2005.         }
  2007.         return (bool) $this->conn->fetchColumn($sql, $params, 0, $types);
  2008.     }
  2010.     /**
  2011.      * Generates the appropriate join SQL for the given join column.
  2012.      *
  2013.      * @param array[] $joinColumns The join columns definition of an association.
  2014.      * @psalm-param array<array<string, mixed>> $joinColumns
  2015.      *
  2016.      * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
  2017.      */
  2018.     protected function getJoinSQLForJoinColumns($joinColumns)
  2019.     {
  2020.         // if one of the join columns is nullable, return left join
  2021.         foreach ($joinColumns as $joinColumn) {
  2022.             if (! isset($joinColumn['nullable']) || $joinColumn['nullable']) {
  2023.                 return 'LEFT JOIN';
  2024.             }
  2025.         }
  2027.         return 'INNER JOIN';
  2028.     }
  2030.     /**
  2031.      * @param string $columnName
  2032.      *
  2033.      * @return string
  2034.      */
  2035.     public function getSQLColumnAlias($columnName)
  2036.     {
  2037.         return $this->quoteStrategy->getColumnAlias($columnName, $this->currentPersisterContext->sqlAliasCounter++, $this->platform);
  2038.     }
  2040.     /**
  2041.      * Generates the filter SQL for a given entity and table alias.
  2042.      *
  2043.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  2044.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  2045.      *
  2046.      * @return string The SQL query part to add to a query.
  2047.      */
  2048.     protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
  2049.     {
  2050.         $filterClauses = [];
  2052.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  2053.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  2054.             if ($filterExpr !== '') {
  2055.                 $filterClauses[] = '(' . $filterExpr . ')';
  2056.             }
  2057.         }
  2059.         $sql = implode(' AND ', $filterClauses);
  2061.         return $sql ? '(' . $sql . ')' : ''; // Wrap again to avoid "X or Y and FilterConditionSQL"
  2062.     }
  2064.     /**
  2065.      * Switches persister context according to current query offset/limits
  2066.      *
  2067.      * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
  2068.      *
  2069.      * @param int|null $offset
  2070.      * @param int|null $limit
  2071.      *
  2072.      * @return void
  2073.      */
  2074.     protected function switchPersisterContext($offset, $limit)
  2075.     {
  2076.         if ($offset === null && $limit === null) {
  2077.             $this->currentPersisterContext = $this->noLimitsContext;
  2079.             return;
  2080.         }
  2082.         $this->currentPersisterContext = $this->limitsHandlingContext;
  2083.     }
  2085.     /**
  2086.      * @return string[]
  2087.      * @psalm-return list<string>
  2088.      */
  2089.     protected function getClassIdentifiersTypes(ClassMetadata $class): array
  2090.     {
  2091.         $entityManager = $this->em;
  2093.         return array_map(
  2094.             static function ($fieldName) use ($class, $entityManager): string {
  2095.                 $types = PersisterHelper::getTypeOfField($fieldName, $class, $entityManager);
  2096.                 assert(isset($types[0]));
  2098.                 return $types[0];
  2099.             },
  2100.             $class->identifier
  2101.         );
  2102.     }
  2103. }