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

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\DBAL\Connection;
  11. use Doctrine\DBAL\LockMode;
  12. use Doctrine\DBAL\Platforms\AbstractPlatform;
  13. use Doctrine\DBAL\Result;
  14. use Doctrine\DBAL\Types\Type;
  15. use Doctrine\DBAL\Types\Types;
  16. use Doctrine\Deprecations\Deprecation;
  17. use Doctrine\ORM\EntityManagerInterface;
  18. use Doctrine\ORM\Internal\CriteriaOrderings;
  19. use Doctrine\ORM\Mapping\ClassMetadata;
  20. use Doctrine\ORM\Mapping\MappingException;
  21. use Doctrine\ORM\Mapping\QuoteStrategy;
  22. use Doctrine\ORM\OptimisticLockException;
  23. use Doctrine\ORM\PersistentCollection;
  24. use Doctrine\ORM\Persisters\Exception\CantUseInOperatorOnCompositeKeys;
  25. use Doctrine\ORM\Persisters\Exception\InvalidOrientation;
  26. use Doctrine\ORM\Persisters\Exception\UnrecognizedField;
  27. use Doctrine\ORM\Persisters\SqlExpressionVisitor;
  28. use Doctrine\ORM\Persisters\SqlValueVisitor;
  29. use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
  30. use Doctrine\ORM\Query;
  31. use Doctrine\ORM\Query\QueryException;
  32. use Doctrine\ORM\Repository\Exception\InvalidFindByCall;
  33. use Doctrine\ORM\UnitOfWork;
  34. use Doctrine\ORM\Utility\IdentifierFlattener;
  35. use Doctrine\ORM\Utility\LockSqlHelper;
  36. use Doctrine\ORM\Utility\PersisterHelper;
  37. use LengthException;
  39. use function array_combine;
  40. use function array_keys;
  41. use function array_map;
  42. use function array_merge;
  43. use function array_search;
  44. use function array_unique;
  45. use function array_values;
  46. use function assert;
  47. use function count;
  48. use function implode;
  49. use function is_array;
  50. use function is_object;
  51. use function reset;
  52. use function spl_object_id;
  53. use function sprintf;
  54. use function str_contains;
  55. use function strtoupper;
  56. use function trim;
  58. /**
  59.  * A BasicEntityPersister maps an entity to a single table in a relational database.
  60.  *
  61.  * A persister is always responsible for a single entity type.
  62.  *
  63.  * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
  64.  * state of entities onto a relational database when the UnitOfWork is committed,
  65.  * as well as for basic querying of entities and their associations (not DQL).
  66.  *
  67.  * The persisting operations that are invoked during a commit of a UnitOfWork to
  68.  * persist the persistent entity state are:
  69.  *
  70.  *   - {@link addInsert} : To schedule an entity for insertion.
  71.  *   - {@link executeInserts} : To execute all scheduled insertions.
  72.  *   - {@link update} : To update the persistent state of an entity.
  73.  *   - {@link delete} : To delete the persistent state of an entity.
  74.  *
  75.  * As can be seen from the above list, insertions are batched and executed all at once
  76.  * for increased efficiency.
  77.  *
  78.  * The querying operations invoked during a UnitOfWork, either through direct find
  79.  * requests or lazy-loading, are the following:
  80.  *
  81.  *   - {@link load} : Loads (the state of) a single, managed entity.
  82.  *   - {@link loadAll} : Loads multiple, managed entities.
  83.  *   - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
  84.  *   - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
  85.  *   - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
  86.  *
  87.  * The BasicEntityPersister implementation provides the default behavior for
  88.  * persisting and querying entities that are mapped to a single database table.
  89.  *
  90.  * Subclasses can be created to provide custom persisting and querying strategies,
  91.  * i.e. spanning multiple tables.
  92.  *
  93.  * @phpstan-import-type AssociationMapping from ClassMetadata
  94.  */
  95. class BasicEntityPersister implements EntityPersister
  96. {
  97.     use CriteriaOrderings;
  98.     use LockSqlHelper;
  100.     /** @var array<string,string> */
  101.     private static $comparisonMap = [
  102.         Comparison::EQ          => '= %s',
  103.         Comparison::NEQ         => '!= %s',
  104.         Comparison::GT          => '> %s',
  105.         Comparison::GTE         => '>= %s',
  106.         Comparison::LT          => '< %s',
  107.         Comparison::LTE         => '<= %s',
  108.         Comparison::IN          => 'IN (%s)',
  109.         Comparison::NIN         => 'NOT IN (%s)',
  110.         Comparison::CONTAINS    => 'LIKE %s',
  111.         Comparison::STARTS_WITH => 'LIKE %s',
  112.         Comparison::ENDS_WITH   => 'LIKE %s',
  113.     ];
  115.     /**
  116.      * Metadata object that describes the mapping of the mapped entity class.
  117.      *
  118.      * @var ClassMetadata
  119.      */
  120.     protected $class;
  122.     /**
  123.      * The underlying DBAL Connection of the used EntityManager.
  124.      *
  125.      * @var Connection $conn
  126.      */
  127.     protected $conn;
  129.     /**
  130.      * The database platform.
  131.      *
  132.      * @var AbstractPlatform
  133.      */
  134.     protected $platform;
  136.     /**
  137.      * The EntityManager instance.
  138.      *
  139.      * @var EntityManagerInterface
  140.      */
  141.     protected $em;
  143.     /**
  144.      * Queued inserts.
  145.      *
  146.      * @phpstan-var array<int, object>
  147.      */
  148.     protected $queuedInserts = [];
  150.     /**
  151.      * The map of column names to DBAL mapping types of all prepared columns used
  152.      * when INSERTing or UPDATEing an entity.
  153.      *
  154.      * @see prepareInsertData($entity)
  155.      * @see prepareUpdateData($entity)
  156.      *
  157.      * @var mixed[]
  158.      */
  159.     protected $columnTypes = [];
  161.     /**
  162.      * The map of quoted column names.
  163.      *
  164.      * @see prepareInsertData($entity)
  165.      * @see prepareUpdateData($entity)
  166.      *
  167.      * @var mixed[]
  168.      */
  169.     protected $quotedColumns = [];
  171.     /**
  172.      * The INSERT SQL statement used for entities handled by this persister.
  173.      * This SQL is only generated once per request, if at all.
  174.      *
  175.      * @var string|null
  176.      */
  177.     private $insertSql;
  179.     /**
  180.      * The quote strategy.
  181.      *
  182.      * @var QuoteStrategy
  183.      */
  184.     protected $quoteStrategy;
  186.     /**
  187.      * The IdentifierFlattener used for manipulating identifiers
  188.      *
  189.      * @var IdentifierFlattener
  190.      */
  191.     protected $identifierFlattener;
  193.     /** @var CachedPersisterContext */
  194.     protected $currentPersisterContext;
  196.     /** @var CachedPersisterContext */
  197.     private $limitsHandlingContext;
  199.     /** @var CachedPersisterContext */
  200.     private $noLimitsContext;
  202.     /** @var ?string */
  203.     private $filterHash = null;
  205.     /**
  206.      * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
  207.      * and persists instances of the class described by the given ClassMetadata descriptor.
  208.      */
  209.     public function __construct(EntityManagerInterface $em, ClassMetadata $class)
  210.     {
  211.         $this->em                    = $em;
  212.         $this->class                 = $class;
  213.         $this->conn                  = $em->getConnection();
  214.         $this->platform              = $this->conn->getDatabasePlatform();
  215.         $this->quoteStrategy         = $em->getConfiguration()->getQuoteStrategy();
  216.         $this->identifierFlattener   = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
  217.         $this->noLimitsContext       = $this->currentPersisterContext = new CachedPersisterContext(
  218.             $class,
  219.             new Query\ResultSetMapping(),
  220.             false
  221.         );
  222.         $this->limitsHandlingContext = new CachedPersisterContext(
  223.             $class,
  224.             new Query\ResultSetMapping(),
  225.             true
  226.         );
  227.     }
  229.     final protected function isFilterHashUpToDate(): bool
  230.     {
  231.         return $this->filterHash === $this->em->getFilters()->getHash();
  232.     }
  234.     final protected function updateFilterHash(): void
  235.     {
  236.         $this->filterHash = $this->em->getFilters()->getHash();
  237.     }
  239.     /**
  240.      * {@inheritDoc}
  241.      */
  242.     public function getClassMetadata()
  243.     {
  244.         return $this->class;
  245.     }
  247.     /**
  248.      * {@inheritDoc}
  249.      */
  250.     public function getResultSetMapping()
  251.     {
  252.         return $this->currentPersisterContext->rsm;
  253.     }
  255.     /**
  256.      * {@inheritDoc}
  257.      */
  258.     public function addInsert($entity)
  259.     {
  260.         $this->queuedInserts[spl_object_id($entity)] = $entity;
  261.     }
  263.     /**
  264.      * {@inheritDoc}
  265.      */
  266.     public function getInserts()
  267.     {
  268.         return $this->queuedInserts;
  269.     }
  271.     /**
  272.      * {@inheritDoc}
  273.      */
  274.     public function executeInserts()
  275.     {
  276.         if (! $this->queuedInserts) {
  277.             return;
  278.         }
  280.         $uow            = $this->em->getUnitOfWork();
  281.         $idGenerator    = $this->class->idGenerator;
  282.         $isPostInsertId = $idGenerator->isPostInsertGenerator();
  284.         $stmt      = $this->conn->prepare($this->getInsertSQL());
  285.         $tableName = $this->class->getTableName();
  287.         foreach ($this->queuedInserts as $key => $entity) {
  288.             $insertData = $this->prepareInsertData($entity);
  290.             if (isset($insertData[$tableName])) {
  291.                 $paramIndex = 1;
  293.                 foreach ($insertData[$tableName] as $column => $value) {
  294.                     $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$column]);
  295.                 }
  296.             }
  298.             $stmt->executeStatement();
  300.             if ($isPostInsertId) {
  301.                 $generatedId = $idGenerator->generateId($this->em, $entity);
  302.                 $id          = [$this->class->identifier[0] => $generatedId];
  304.                 $uow->assignPostInsertId($entity, $generatedId);
  305.             } else {
  306.                 $id = $this->class->getIdentifierValues($entity);
  307.             }
  309.             if ($this->class->requiresFetchAfterChange) {
  310.                 $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  311.             }
  313.             // Unset this queued insert, so that the prepareUpdateData() method knows right away
  314.             // (for the next entity already) that the current entity has been written to the database
  315.             // and no extra updates need to be scheduled to refer to it.
  316.             //
  317.             // In \Doctrine\ORM\UnitOfWork::executeInserts(), the UoW already removed entities
  318.             // from its own list (\Doctrine\ORM\UnitOfWork::$entityInsertions) right after they
  319.             // were given to our addInsert() method.
  320.             unset($this->queuedInserts[$key]);
  321.         }
  322.     }
  324.     /**
  325.      * Retrieves the default version value which was created
  326.      * by the preceding INSERT statement and assigns it back in to the
  327.      * entities version field if the given entity is versioned.
  328.      * Also retrieves values of columns marked as 'non insertable' and / or
  329.      * 'not updatable' and assigns them back to the entities corresponding fields.
  330.      *
  331.      * @param object  $entity
  332.      * @param mixed[] $id
  333.      *
  334.      * @return void
  335.      */
  336.     protected function assignDefaultVersionAndUpsertableValues($entity, array $id)
  337.     {
  338.         $values = $this->fetchVersionAndNotUpsertableValues($this->class, $id);
  340.         foreach ($values as $field => $value) {
  341.             $value = Type::getType($this->class->fieldMappings[$field]['type'])->convertToPHPValue($value, $this->platform);
  343.             $this->class->setFieldValue($entity, $field, $value);
  344.         }
  345.     }
  347.     /**
  348.      * Fetches the current version value of a versioned entity and / or the values of fields
  349.      * marked as 'not insertable' and / or 'not updatable'.
  350.      *
  351.      * @param ClassMetadata $versionedClass
  352.      * @param mixed[]       $id
  353.      *
  354.      * @return mixed
  355.      */
  356.     protected function fetchVersionAndNotUpsertableValues($versionedClass, array $id)
  357.     {
  358.         $columnNames = [];
  359.         foreach ($this->class->fieldMappings as $key => $column) {
  360.             if (isset($column['generated']) || ($this->class->isVersioned && $key === $versionedClass->versionField)) {
  361.                 $columnNames[$key] = $this->quoteStrategy->getColumnName($key, $versionedClass, $this->platform);
  362.             }
  363.         }
  365.         $tableName  = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
  366.         $identifier = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
  368.         // FIXME: Order with composite keys might not be correct
  369.         $sql = 'SELECT ' . implode(', ', $columnNames)
  370.             . ' FROM ' . $tableName
  371.             . ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
  373.         $flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
  375.         $values = $this->conn->fetchNumeric(
  376.             $sql,
  377.             array_values($flatId),
  378.             $this->extractIdentifierTypes($id, $versionedClass)
  379.         );
  381.         if ($values === false) {
  382.             throw new LengthException('Unexpected empty result for database query.');
  383.         }
  385.         $values = array_combine(array_keys($columnNames), $values);
  387.         if (! $values) {
  388.             throw new LengthException('Unexpected number of database columns.');
  389.         }
  391.         return $values;
  392.     }
  394.     /**
  395.      * @param mixed[] $id
  396.      *
  397.      * @return int[]|null[]|string[]
  398.      * @phpstan-return list<int|string|null>
  399.      */
  400.     final protected function extractIdentifierTypes(array $id, ClassMetadata $versionedClass): array
  401.     {
  402.         $types = [];
  404.         foreach ($id as $field => $value) {
  405.             $types = array_merge($types, $this->getTypes($field, $value, $versionedClass));
  406.         }
  408.         return $types;
  409.     }
  411.     /**
  412.      * {@inheritDoc}
  413.      */
  414.     public function update($entity)
  415.     {
  416.         $tableName  = $this->class->getTableName();
  417.         $updateData = $this->prepareUpdateData($entity);
  419.         if (! isset($updateData[$tableName])) {
  420.             return;
  421.         }
  423.         $data = $updateData[$tableName];
  425.         if (! $data) {
  426.             return;
  427.         }
  429.         $isVersioned     = $this->class->isVersioned;
  430.         $quotedTableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  432.         $this->updateTable($entity, $quotedTableName, $data, $isVersioned);
  434.         if ($this->class->requiresFetchAfterChange) {
  435.             $id = $this->class->getIdentifierValues($entity);
  437.             $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  438.         }
  439.     }
  441.     /**
  442.      * Performs an UPDATE statement for an entity on a specific table.
  443.      * The UPDATE can optionally be versioned, which requires the entity to have a version field.
  444.      *
  445.      * @param object  $entity          The entity object being updated.
  446.      * @param string  $quotedTableName The quoted name of the table to apply the UPDATE on.
  447.      * @param mixed[] $updateData      The map of columns to update (column => value).
  448.      * @param bool    $versioned       Whether the UPDATE should be versioned.
  449.      *
  450.      * @throws UnrecognizedField
  451.      * @throws OptimisticLockException
  452.      */
  453.     final protected function updateTable(
  454.         $entity,
  455.         $quotedTableName,
  456.         array $updateData,
  457.         $versioned = false
  458.     ): void {
  459.         $set    = [];
  460.         $types  = [];
  461.         $params = [];
  463.         foreach ($updateData as $columnName => $value) {
  464.             $placeholder = '?';
  465.             $column      = $columnName;
  467.             switch (true) {
  468.                 case isset($this->class->fieldNames[$columnName]):
  469.                     $fieldName = $this->class->fieldNames[$columnName];
  470.                     $column    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  472.                     if (isset($this->class->fieldMappings[$fieldName]['requireSQLConversion'])) {
  473.                         $type        = Type::getType($this->columnTypes[$columnName]);
  474.                         $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  475.                     }
  477.                     break;
  479.                 case isset($this->quotedColumns[$columnName]):
  480.                     $column = $this->quotedColumns[$columnName];
  482.                     break;
  483.             }
  485.             $params[] = $value;
  486.             $set[]    = $column . ' = ' . $placeholder;
  487.             $types[]  = $this->columnTypes[$columnName];
  488.         }
  490.         $where      = [];
  491.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  493.         foreach ($this->class->identifier as $idField) {
  494.             if (! isset($this->class->associationMappings[$idField])) {
  495.                 $params[] = $identifier[$idField];
  496.                 $types[]  = $this->class->fieldMappings[$idField]['type'];
  497.                 $where[]  = $this->quoteStrategy->getColumnName($idField, $this->class, $this->platform);
  499.                 continue;
  500.             }
  502.             $params[] = $identifier[$idField];
  503.             $where[]  = $this->quoteStrategy->getJoinColumnName(
  504.                 $this->class->associationMappings[$idField]['joinColumns'][0],
  505.                 $this->class,
  506.                 $this->platform
  507.             );
  509.             $targetMapping = $this->em->getClassMetadata($this->class->associationMappings[$idField]['targetEntity']);
  510.             $targetType    = PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping, $this->em);
  512.             if ($targetType === []) {
  513.                 throw UnrecognizedField::byFullyQualifiedName($this->class->name, $targetMapping->identifier[0]);
  514.             }
  516.             $types[] = reset($targetType);
  517.         }
  519.         if ($versioned) {
  520.             $versionField = $this->class->versionField;
  521.             assert($versionField !== null);
  522.             $versionFieldType = $this->class->fieldMappings[$versionField]['type'];
  523.             $versionColumn    = $this->quoteStrategy->getColumnName($versionField, $this->class, $this->platform);
  525.             $where[]  = $versionColumn;
  526.             $types[]  = $this->class->fieldMappings[$versionField]['type'];
  527.             $params[] = $this->class->reflFields[$versionField]->getValue($entity);
  529.             switch ($versionFieldType) {
  530.                 case Types::SMALLINT:
  531.                 case Types::INTEGER:
  532.                 case Types::BIGINT:
  533.                     $set[] = $versionColumn . ' = ' . $versionColumn . ' + 1';
  534.                     break;
  536.                 case Types::DATETIME_MUTABLE:
  537.                     $set[] = $versionColumn . ' = CURRENT_TIMESTAMP';
  538.                     break;
  539.             }
  540.         }
  542.         $sql = 'UPDATE ' . $quotedTableName
  543.              . ' SET ' . implode(', ', $set)
  544.              . ' WHERE ' . implode(' = ? AND ', $where) . ' = ?';
  546.         $result = $this->conn->executeStatement($sql, $params, $types);
  548.         if ($versioned && ! $result) {
  549.             throw OptimisticLockException::lockFailed($entity);
  550.         }
  551.     }
  553.     /**
  554.      * @param array<mixed> $identifier
  555.      * @param string[]     $types
  556.      *
  557.      * @todo Add check for platform if it supports foreign keys/cascading.
  558.      */
  559.     protected function deleteJoinTableRecords(array $identifier, array $types): void
  560.     {
  561.         foreach ($this->class->associationMappings as $mapping) {
  562.             if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY || isset($mapping['isOnDeleteCascade'])) {
  563.                 continue;
  564.             }
  566.             // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
  567.             // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
  568.             $selfReferential = ($mapping['targetEntity'] === $mapping['sourceEntity']);
  569.             $class           = $this->class;
  570.             $association     = $mapping;
  571.             $otherColumns    = [];
  572.             $otherKeys       = [];
  573.             $keys            = [];
  575.             if (! $mapping['isOwningSide']) {
  576.                 $class       = $this->em->getClassMetadata($mapping['targetEntity']);
  577.                 $association = $class->associationMappings[$mapping['mappedBy']];
  578.             }
  580.             $joinColumns = $mapping['isOwningSide']
  581.                 ? $association['joinTable']['joinColumns']
  582.                 : $association['joinTable']['inverseJoinColumns'];
  584.             if ($selfReferential) {
  585.                 $otherColumns = ! $mapping['isOwningSide']
  586.                     ? $association['joinTable']['joinColumns']
  587.                     : $association['joinTable']['inverseJoinColumns'];
  588.             }
  590.             foreach ($joinColumns as $joinColumn) {
  591.                 $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  592.             }
  594.             foreach ($otherColumns as $joinColumn) {
  595.                 $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  596.             }
  598.             $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  600.             $this->conn->delete($joinTableName, array_combine($keys, $identifier), $types);
  602.             if ($selfReferential) {
  603.                 $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier), $types);
  604.             }
  605.         }
  606.     }
  608.     /**
  609.      * {@inheritDoc}
  610.      */
  611.     public function delete($entity)
  612.     {
  613.         $class      = $this->class;
  614.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  615.         $tableName  = $this->quoteStrategy->getTableName($class, $this->platform);
  616.         $idColumns  = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform);
  617.         $id         = array_combine($idColumns, $identifier);
  618.         $types      = $this->getClassIdentifiersTypes($class);
  620.         $this->deleteJoinTableRecords($identifier, $types);
  622.         return (bool) $this->conn->delete($tableName, $id, $types);
  623.     }
  625.     /**
  626.      * Prepares the changeset of an entity for database insertion (UPDATE).
  627.      *
  628.      * The changeset is obtained from the currently running UnitOfWork.
  629.      *
  630.      * During this preparation the array that is passed as the second parameter is filled with
  631.      * <columnName> => <value> pairs, grouped by table name.
  632.      *
  633.      * Example:
  634.      * <code>
  635.      * array(
  636.      *    'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
  637.      *    'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
  638.      *    ...
  639.      * )
  640.      * </code>
  641.      *
  642.      * @param object $entity   The entity for which to prepare the data.
  643.      * @param bool   $isInsert Whether the data to be prepared refers to an insert statement.
  644.      *
  645.      * @return mixed[][] The prepared data.
  646.      * @phpstan-return array<string, array<array-key, mixed|null>>
  647.      */
  648.     protected function prepareUpdateData($entity, bool $isInsert = false)
  649.     {
  650.         $versionField = null;
  651.         $result       = [];
  652.         $uow          = $this->em->getUnitOfWork();
  654.         $versioned = $this->class->isVersioned;
  655.         if ($versioned !== false) {
  656.             $versionField = $this->class->versionField;
  657.         }
  659.         foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
  660.             if (isset($versionField) && $versionField === $field) {
  661.                 continue;
  662.             }
  664.             if (isset($this->class->embeddedClasses[$field])) {
  665.                 continue;
  666.             }
  668.             $newVal = $change[1];
  670.             if (! isset($this->class->associationMappings[$field])) {
  671.                 $fieldMapping = $this->class->fieldMappings[$field];
  672.                 $columnName   = $fieldMapping['columnName'];
  674.                 if (! $isInsert && isset($fieldMapping['notUpdatable'])) {
  675.                     continue;
  676.                 }
  678.                 if ($isInsert && isset($fieldMapping['notInsertable'])) {
  679.                     continue;
  680.                 }
  682.                 $this->columnTypes[$columnName] = $fieldMapping['type'];
  684.                 $result[$this->getOwningTable($field)][$columnName] = $newVal;
  686.                 continue;
  687.             }
  689.             $assoc = $this->class->associationMappings[$field];
  691.             // Only owning side of x-1 associations can have a FK column.
  692.             if (! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
  693.                 continue;
  694.             }
  696.             if ($newVal !== null) {
  697.                 $oid = spl_object_id($newVal);
  699.                 // If the associated entity $newVal is not yet persisted and/or does not yet have
  700.                 // an ID assigned, we must set $newVal = null. This will insert a null value and
  701.                 // schedule an extra update on the UnitOfWork.
  702.                 //
  703.                 // This gives us extra time to a) possibly obtain a database-generated identifier
  704.                 // value for $newVal, and b) insert $newVal into the database before the foreign
  705.                 // key reference is being made.
  706.                 //
  707.                 // When looking at $this->queuedInserts and $uow->isScheduledForInsert, be aware
  708.                 // of the implementation details that our own executeInserts() method will remove
  709.                 // entities from the former as soon as the insert statement has been executed and
  710.                 // a post-insert ID has been assigned (if necessary), and that the UnitOfWork has
  711.                 // already removed entities from its own list at the time they were passed to our
  712.                 // addInsert() method.
  713.                 //
  714.                 // Then, there is one extra exception we can make: An entity that references back to itself
  715.                 // _and_ uses an application-provided ID (the "NONE" generator strategy) also does not
  716.                 // need the extra update, although it is still in the list of insertions itself.
  717.                 // This looks like a minor optimization at first, but is the capstone for being able to
  718.                 // use non-NULLable, self-referencing associations in applications that provide IDs (like UUIDs).
  719.                 if (
  720.                     (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal))
  721.                     && ! ($newVal === $entity && $this->class->isIdentifierNatural())
  722.                 ) {
  723.                     $uow->scheduleExtraUpdate($entity, [$field => [null, $newVal]]);
  725.                     $newVal = null;
  726.                 }
  727.             }
  729.             $newValId = null;
  731.             if ($newVal !== null) {
  732.                 $newValId = $uow->getEntityIdentifier($newVal);
  733.             }
  735.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  736.             $owningTable = $this->getOwningTable($field);
  738.             foreach ($assoc['joinColumns'] as $joinColumn) {
  739.                 $sourceColumn = $joinColumn['name'];
  740.                 $targetColumn = $joinColumn['referencedColumnName'];
  741.                 $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  743.                 $this->quotedColumns[$sourceColumn]  = $quotedColumn;
  744.                 $this->columnTypes[$sourceColumn]    = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
  745.                 $result[$owningTable][$sourceColumn] = $newValId
  746.                     ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
  747.                     : null;
  748.             }
  749.         }
  751.         return $result;
  752.     }
  754.     /**
  755.      * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
  756.      * The changeset of the entity is obtained from the currently running UnitOfWork.
  757.      *
  758.      * The default insert data preparation is the same as for updates.
  759.      *
  760.      * @see prepareUpdateData
  761.      *
  762.      * @param object $entity The entity for which to prepare the data.
  763.      *
  764.      * @return mixed[][] The prepared data for the tables to update.
  765.      * @phpstan-return array<string, mixed[]>
  766.      */
  767.     protected function prepareInsertData($entity)
  768.     {
  769.         return $this->prepareUpdateData($entity, true);
  770.     }
  772.     /**
  773.      * {@inheritDoc}
  774.      */
  775.     public function getOwningTable($fieldName)
  776.     {
  777.         return $this->class->getTableName();
  778.     }
  780.     /**
  781.      * {@inheritDoc}
  782.      */
  783.     public function load(array $criteria, $entity = null, $assoc = null, array $hints = [], $lockMode = null, $limit = null, ?array $orderBy = null)
  784.     {
  785.         $this->switchPersisterContext(null, $limit);
  787.         $sql              = $this->getSelectSQL($criteria, $assoc, $lockMode, $limit, null, $orderBy);
  788.         [$params, $types] = $this->expandParameters($criteria);
  789.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  791.         if ($entity !== null) {
  792.             $hints[Query::HINT_REFRESH]        = true;
  793.             $hints[Query::HINT_REFRESH_ENTITY] = $entity;
  794.         }
  796.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  797.         $entities = $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, $hints);
  799.         return $entities ? $entities[0] : null;
  800.     }
  802.     /**
  803.      * {@inheritDoc}
  804.      */
  805.     public function loadById(array $identifier, $entity = null)
  806.     {
  807.         return $this->load($identifier, $entity);
  808.     }
  810.     /**
  811.      * {@inheritDoc}
  812.      */
  813.     public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
  814.     {
  815.         $foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc['targetEntity']);
  816.         if ($foundEntity !== false) {
  817.             return $foundEntity;
  818.         }
  820.         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  822.         if ($assoc['isOwningSide']) {
  823.             $isInverseSingleValued = $assoc['inversedBy'] && ! $targetClass->isCollectionValuedAssociation($assoc['inversedBy']);
  825.             // Mark inverse side as fetched in the hints, otherwise the UoW would
  826.             // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
  827.             $hints = [];
  829.             if ($isInverseSingleValued) {
  830.                 $hints['fetched']['r'][$assoc['inversedBy']] = true;
  831.             }
  833.             $targetEntity = $this->load($identifier, null, $assoc, $hints);
  835.             // Complete bidirectional association, if necessary
  836.             if ($targetEntity !== null && $isInverseSingleValued) {
  837.                 $targetClass->reflFields[$assoc['inversedBy']]->setValue($targetEntity, $sourceEntity);
  838.             }
  840.             return $targetEntity;
  841.         }
  843.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  844.         $owningAssoc = $targetClass->getAssociationMapping($assoc['mappedBy']);
  846.         $computedIdentifier = [];
  848.         /** @var array<string,mixed>|null $sourceEntityData */
  849.         $sourceEntityData = null;
  851.         // TRICKY: since the association is specular source and target are flipped
  852.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  853.             if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
  854.                 // The likely case here is that the column is a join column
  855.                 // in an association mapping. However, there is no guarantee
  856.                 // at this point that a corresponding (generally identifying)
  857.                 // association has been mapped in the source entity. To handle
  858.                 // this case we directly reference the column-keyed data used
  859.                 // to initialize the source entity before throwing an exception.
  860.                 $resolvedSourceData = false;
  861.                 if (! isset($sourceEntityData)) {
  862.                     $sourceEntityData = $this->em->getUnitOfWork()->getOriginalEntityData($sourceEntity);
  863.                 }
  865.                 if (isset($sourceEntityData[$sourceKeyColumn])) {
  866.                     $dataValue = $sourceEntityData[$sourceKeyColumn];
  867.                     if ($dataValue !== null) {
  868.                         $resolvedSourceData                                                    = true;
  869.                         $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  870.                             $dataValue;
  871.                     }
  872.                 }
  874.                 if (! $resolvedSourceData) {
  875.                     throw MappingException::joinColumnMustPointToMappedField(
  876.                         $sourceClass->name,
  877.                         $sourceKeyColumn
  878.                     );
  879.                 }
  880.             } else {
  881.                 $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  882.                     $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
  883.             }
  884.         }
  886.         $targetEntity = $this->load($computedIdentifier, null, $assoc);
  888.         if ($targetEntity !== null) {
  889.             $targetClass->setFieldValue($targetEntity, $assoc['mappedBy'], $sourceEntity);
  890.         }
  892.         return $targetEntity;
  893.     }
  895.     /**
  896.      * {@inheritDoc}
  897.      */
  898.     public function refresh(array $id, $entity, $lockMode = null)
  899.     {
  900.         $sql              = $this->getSelectSQL($id, null, $lockMode);
  901.         [$params, $types] = $this->expandParameters($id);
  902.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  904.         $hydrator = $this->em->newHydrator(Query::HYDRATE_OBJECT);
  905.         $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
  906.     }
  908.     /**
  909.      * {@inheritDoc}
  910.      */
  911.     public function count($criteria = [])
  912.     {
  913.         $sql = $this->getCountSQL($criteria);
  915.         [$params, $types] = $criteria instanceof Criteria
  916.             ? $this->expandCriteriaParameters($criteria)
  917.             : $this->expandParameters($criteria);
  919.         return (int) $this->conn->executeQuery($sql, $params, $types)->fetchOne();
  920.     }
  922.     /**
  923.      * {@inheritDoc}
  924.      */
  925.     public function loadCriteria(Criteria $criteria)
  926.     {
  927.         $orderBy = self::getCriteriaOrderings($criteria);
  928.         $limit   = $criteria->getMaxResults();
  929.         $offset  = $criteria->getFirstResult();
  930.         $query   = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  932.         [$params, $types] = $this->expandCriteriaParameters($criteria);
  934.         $stmt     = $this->conn->executeQuery($query, $params, $types);
  935.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  937.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  938.     }
  940.     /**
  941.      * {@inheritDoc}
  942.      */
  943.     public function expandCriteriaParameters(Criteria $criteria)
  944.     {
  945.         $expression = $criteria->getWhereExpression();
  946.         $sqlParams  = [];
  947.         $sqlTypes   = [];
  949.         if ($expression === null) {
  950.             return [$sqlParams, $sqlTypes];
  951.         }
  953.         $valueVisitor = new SqlValueVisitor();
  955.         $valueVisitor->dispatch($expression);
  957.         [, $types] = $valueVisitor->getParamsAndTypes();
  959.         foreach ($types as $type) {
  960.             [$field, $value, $operator] = $type;
  962.             if ($value === null && ($operator === Comparison::EQ || $operator === Comparison::NEQ)) {
  963.                 continue;
  964.             }
  966.             $sqlParams = array_merge($sqlParams, $this->getValues($value));
  967.             $sqlTypes  = array_merge($sqlTypes, $this->getTypes($field, $value, $this->class));
  968.         }
  970.         return [$sqlParams, $sqlTypes];
  971.     }
  973.     /**
  974.      * {@inheritDoc}
  975.      */
  976.     public function loadAll(array $criteria = [], ?array $orderBy = null, $limit = null, $offset = null)
  977.     {
  978.         $this->switchPersisterContext($offset, $limit);
  980.         $sql              = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  981.         [$params, $types] = $this->expandParameters($criteria);
  982.         $stmt             = $this->conn->executeQuery($sql, $params, $types);
  984.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  986.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  987.     }
  989.     /**
  990.      * {@inheritDoc}
  991.      */
  992.     public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  993.     {
  994.         $this->switchPersisterContext($offset, $limit);
  996.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity, $offset, $limit);
  998.         return $this->loadArrayFromResult($assoc, $stmt);
  999.     }
  1001.     /**
  1002.      * Loads an array of entities from a given DBAL statement.
  1003.      *
  1004.      * @param mixed[] $assoc
  1005.      *
  1006.      * @return mixed[]
  1007.      */
  1008.     private function loadArrayFromResult(array $assoc, Result $stmt): array
  1009.     {
  1010.         $rsm   = $this->currentPersisterContext->rsm;
  1011.         $hints = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
  1013.         if (isset($assoc['indexBy'])) {
  1014.             $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  1015.             $rsm->addIndexBy('r', $assoc['indexBy']);
  1016.         }
  1018.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  1019.     }
  1021.     /**
  1022.      * Hydrates a collection from a given DBAL statement.
  1023.      *
  1024.      * @param mixed[] $assoc
  1025.      *
  1026.      * @return mixed[]
  1027.      */
  1028.     private function loadCollectionFromStatement(
  1029.         array $assoc,
  1030.         Result $stmt,
  1031.         PersistentCollection $coll
  1032.     ): array {
  1033.         $rsm   = $this->currentPersisterContext->rsm;
  1034.         $hints = [
  1035.             UnitOfWork::HINT_DEFEREAGERLOAD => true,
  1036.             'collection' => $coll,
  1037.         ];
  1039.         if (isset($assoc['indexBy'])) {
  1040.             $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  1041.             $rsm->addIndexBy('r', $assoc['indexBy']);
  1042.         }
  1044.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  1045.     }
  1047.     /**
  1048.      * {@inheritDoc}
  1049.      */
  1050.     public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1051.     {
  1052.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity);
  1054.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1055.     }
  1057.     /**
  1058.      * @param object $sourceEntity
  1059.      * @phpstan-param array<string, mixed> $assoc
  1060.      *
  1061.      * @return Result
  1062.      *
  1063.      * @throws MappingException
  1064.      */
  1065.     private function getManyToManyStatement(
  1066.         array $assoc,
  1067.         $sourceEntity,
  1068.         ?int $offset = null,
  1069.         ?int $limit = null
  1070.     ) {
  1071.         $this->switchPersisterContext($offset, $limit);
  1073.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1074.         $class       = $sourceClass;
  1075.         $association = $assoc;
  1076.         $criteria    = [];
  1077.         $parameters  = [];
  1079.         if (! $assoc['isOwningSide']) {
  1080.             $class       = $this->em->getClassMetadata($assoc['targetEntity']);
  1081.             $association = $class->associationMappings[$assoc['mappedBy']];
  1082.         }
  1084.         $joinColumns = $assoc['isOwningSide']
  1085.             ? $association['joinTable']['joinColumns']
  1086.             : $association['joinTable']['inverseJoinColumns'];
  1088.         $quotedJoinTable = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1090.         foreach ($joinColumns as $joinColumn) {
  1091.             $sourceKeyColumn = $joinColumn['referencedColumnName'];
  1092.             $quotedKeyColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1094.             switch (true) {
  1095.                 case $sourceClass->containsForeignIdentifier:
  1096.                     $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1097.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1099.                     if (isset($sourceClass->associationMappings[$field])) {
  1100.                         $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1101.                         $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1102.                     }
  1104.                     break;
  1106.                 case isset($sourceClass->fieldNames[$sourceKeyColumn]):
  1107.                     $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1108.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1110.                     break;
  1112.                 default:
  1113.                     throw MappingException::joinColumnMustPointToMappedField(
  1114.                         $sourceClass->name,
  1115.                         $sourceKeyColumn
  1116.                     );
  1117.             }
  1119.             $criteria[$quotedJoinTable . '.' . $quotedKeyColumn] = $value;
  1120.             $parameters[]                                        = [
  1121.                 'value' => $value,
  1122.                 'field' => $field,
  1123.                 'class' => $sourceClass,
  1124.             ];
  1125.         }
  1127.         $sql              = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1128.         [$params, $types] = $this->expandToManyParameters($parameters);
  1130.         return $this->conn->executeQuery($sql, $params, $types);
  1131.     }
  1133.     /**
  1134.      * {@inheritDoc}
  1135.      */
  1136.     public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, ?array $orderBy = null)
  1137.     {
  1138.         $this->switchPersisterContext($offset, $limit);
  1140.         $lockSql    = '';
  1141.         $joinSql    = '';
  1142.         $orderBySql = '';
  1144.         if ($assoc !== null && $assoc['type'] === ClassMetadata::MANY_TO_MANY) {
  1145.             $joinSql = $this->getSelectManyToManyJoinSQL($assoc);
  1146.         }
  1148.         if (isset($assoc['orderBy'])) {
  1149.             $orderBy = $assoc['orderBy'];
  1150.         }
  1152.         if ($orderBy) {
  1153.             $orderBySql = $this->getOrderBySQL($orderBy, $this->getSQLTableAlias($this->class->name));
  1154.         }
  1156.         $conditionSql = $criteria instanceof Criteria
  1157.             ? $this->getSelectConditionCriteriaSQL($criteria)
  1158.             : $this->getSelectConditionSQL($criteria, $assoc);
  1160.         switch ($lockMode) {
  1161.             case LockMode::PESSIMISTIC_READ:
  1162.                 $lockSql = ' ' . $this->getReadLockSQL($this->platform);
  1163.                 break;
  1165.             case LockMode::PESSIMISTIC_WRITE:
  1166.                 $lockSql = ' ' . $this->getWriteLockSQL($this->platform);
  1167.                 break;
  1168.         }
  1170.         $columnList = $this->getSelectColumnsSQL();
  1171.         $tableAlias = $this->getSQLTableAlias($this->class->name);
  1172.         $filterSql  = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1173.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1175.         if ($filterSql !== '') {
  1176.             $conditionSql = $conditionSql
  1177.                 ? $conditionSql . ' AND ' . $filterSql
  1178.                 : $filterSql;
  1179.         }
  1181.         $select = 'SELECT ' . $columnList;
  1182.         $from   = ' FROM ' . $tableName . ' ' . $tableAlias;
  1183.         $join   = $this->currentPersisterContext->selectJoinSql . $joinSql;
  1184.         $where  = ($conditionSql ? ' WHERE ' . $conditionSql : '');
  1185.         $lock   = $this->platform->appendLockHint($from, $lockMode ?? LockMode::NONE);
  1186.         $query  = $select
  1187.             . $lock
  1188.             . $join
  1189.             . $where
  1190.             . $orderBySql;
  1192.         return $this->platform->modifyLimitQuery($query, $limit, $offset ?? 0) . $lockSql;
  1193.     }
  1195.     /**
  1196.      * {@inheritDoc}
  1197.      */
  1198.     public function getCountSQL($criteria = [])
  1199.     {
  1200.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1201.         $tableAlias = $this->getSQLTableAlias($this->class->name);
  1203.         $conditionSql = $criteria instanceof Criteria
  1204.             ? $this->getSelectConditionCriteriaSQL($criteria)
  1205.             : $this->getSelectConditionSQL($criteria);
  1207.         $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1209.         if ($filterSql !== '') {
  1210.             $conditionSql = $conditionSql
  1211.                 ? $conditionSql . ' AND ' . $filterSql
  1212.                 : $filterSql;
  1213.         }
  1215.         return 'SELECT COUNT(*) '
  1216.             . 'FROM ' . $tableName . ' ' . $tableAlias
  1217.             . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
  1218.     }
  1220.     /**
  1221.      * Gets the ORDER BY SQL snippet for ordered collections.
  1222.      *
  1223.      * @phpstan-param array<string, string> $orderBy
  1224.      *
  1225.      * @throws InvalidOrientation
  1226.      * @throws InvalidFindByCall
  1227.      * @throws UnrecognizedField
  1228.      */
  1229.     final protected function getOrderBySQL(array $orderBy, string $baseTableAlias): string
  1230.     {
  1231.         $orderByList = [];
  1233.         foreach ($orderBy as $fieldName => $orientation) {
  1234.             $orientation = strtoupper(trim($orientation));
  1236.             if ($orientation !== 'ASC' && $orientation !== 'DESC') {
  1237.                 throw InvalidOrientation::fromClassNameAndField($this->class->name, $fieldName);
  1238.             }
  1240.             if (isset($this->class->fieldMappings[$fieldName])) {
  1241.                 $tableAlias = isset($this->class->fieldMappings[$fieldName]['inherited'])
  1242.                     ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
  1243.                     : $baseTableAlias;
  1245.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  1246.                 $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1248.                 continue;
  1249.             }
  1251.             if (isset($this->class->associationMappings[$fieldName])) {
  1252.                 if (! $this->class->associationMappings[$fieldName]['isOwningSide']) {
  1253.                     throw InvalidFindByCall::fromInverseSideUsage($this->class->name, $fieldName);
  1254.                 }
  1256.                 $tableAlias = isset($this->class->associationMappings[$fieldName]['inherited'])
  1257.                     ? $this->getSQLTableAlias($this->class->associationMappings[$fieldName]['inherited'])
  1258.                     : $baseTableAlias;
  1260.                 foreach ($this->class->associationMappings[$fieldName]['joinColumns'] as $joinColumn) {
  1261.                     $columnName    = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1262.                     $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1263.                 }
  1265.                 continue;
  1266.             }
  1268.             throw UnrecognizedField::byFullyQualifiedName($this->class->name, $fieldName);
  1269.         }
  1271.         return ' ORDER BY ' . implode(', ', $orderByList);
  1272.     }
  1274.     /**
  1275.      * Gets the SQL fragment with the list of columns to select when querying for
  1276.      * an entity in this persister.
  1277.      *
  1278.      * Subclasses should override this method to alter or change the select column
  1279.      * list SQL fragment. Note that in the implementation of BasicEntityPersister
  1280.      * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
  1281.      * Subclasses may or may not do the same.
  1282.      *
  1283.      * @return string The SQL fragment.
  1284.      */
  1285.     protected function getSelectColumnsSQL()
  1286.     {
  1287.         if ($this->currentPersisterContext->selectColumnListSql !== null && $this->isFilterHashUpToDate()) {
  1288.             return $this->currentPersisterContext->selectColumnListSql;
  1289.         }
  1291.         $columnList = [];
  1292.         $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r'); // r for root
  1294.         // Add regular columns to select list
  1295.         foreach ($this->class->fieldNames as $field) {
  1296.             $columnList[] = $this->getSelectColumnSQL($field, $this->class);
  1297.         }
  1299.         $this->currentPersisterContext->selectJoinSql = '';
  1300.         $eagerAliasCounter                            = 0;
  1302.         foreach ($this->class->associationMappings as $assocField => $assoc) {
  1303.             $assocColumnSQL = $this->getSelectColumnAssociationSQL($assocField, $assoc, $this->class);
  1305.             if ($assocColumnSQL) {
  1306.                 $columnList[] = $assocColumnSQL;
  1307.             }
  1309.             $isAssocToOneInverseSide = $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
  1310.             $isAssocFromOneEager     = $assoc['type'] & ClassMetadata::TO_ONE && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
  1312.             if (! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
  1313.                 continue;
  1314.             }
  1316.             if ((($assoc['type'] & ClassMetadata::TO_MANY) > 0) && $this->currentPersisterContext->handlesLimits) {
  1317.                 continue;
  1318.             }
  1320.             $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1322.             if ($eagerEntity->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  1323.                 continue; // now this is why you shouldn't use inheritance
  1324.             }
  1326.             $assocAlias = 'e' . ($eagerAliasCounter++);
  1327.             $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc['targetEntity'], $assocAlias, 'r', $assocField);
  1329.             foreach ($eagerEntity->fieldNames as $field) {
  1330.                 $columnList[] = $this->getSelectColumnSQL($field, $eagerEntity, $assocAlias);
  1331.             }
  1333.             foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
  1334.                 $eagerAssocColumnSQL = $this->getSelectColumnAssociationSQL(
  1335.                     $eagerAssocField,
  1336.                     $eagerAssoc,
  1337.                     $eagerEntity,
  1338.                     $assocAlias
  1339.                 );
  1341.                 if ($eagerAssocColumnSQL) {
  1342.                     $columnList[] = $eagerAssocColumnSQL;
  1343.                 }
  1344.             }
  1346.             $association   = $assoc;
  1347.             $joinCondition = [];
  1349.             if (isset($assoc['indexBy'])) {
  1350.                 $this->currentPersisterContext->rsm->addIndexBy($assocAlias, $assoc['indexBy']);
  1351.             }
  1353.             if (! $assoc['isOwningSide']) {
  1354.                 $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1355.                 $association = $eagerEntity->getAssociationMapping($assoc['mappedBy']);
  1356.             }
  1358.             $joinTableAlias = $this->getSQLTableAlias($eagerEntity->name, $assocAlias);
  1359.             $joinTableName  = $this->quoteStrategy->getTableName($eagerEntity, $this->platform);
  1361.             if ($assoc['isOwningSide']) {
  1362.                 $tableAlias                                    = $this->getSQLTableAlias($association['targetEntity'], $assocAlias);
  1363.                 $this->currentPersisterContext->selectJoinSql .= ' ' . $this->getJoinSQLForJoinColumns($association['joinColumns']);
  1365.                 foreach ($association['joinColumns'] as $joinColumn) {
  1366.                     $sourceCol       = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1367.                     $targetCol       = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1368.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'])
  1369.                                         . '.' . $sourceCol . ' = ' . $tableAlias . '.' . $targetCol;
  1370.                 }
  1372.                 // Add filter SQL
  1373.                 $filterSql = $this->generateFilterConditionSQL($eagerEntity, $tableAlias);
  1374.                 if ($filterSql) {
  1375.                     $joinCondition[] = $filterSql;
  1376.                 }
  1377.             } else {
  1378.                 $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
  1380.                 foreach ($association['joinColumns'] as $joinColumn) {
  1381.                     $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1382.                     $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1384.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'], $assocAlias) . '.' . $sourceCol . ' = '
  1385.                         . $this->getSQLTableAlias($association['targetEntity']) . '.' . $targetCol;
  1386.                 }
  1388.                 // Add filter SQL
  1389.                 $filterSql = $this->generateFilterConditionSQL($eagerEntity, $joinTableAlias);
  1390.                 if ($filterSql) {
  1391.                     $joinCondition[] = $filterSql;
  1392.                 }
  1393.             }
  1395.             $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';
  1396.             $this->currentPersisterContext->selectJoinSql .= implode(' AND ', $joinCondition);
  1397.         }
  1399.         $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
  1400.         $this->updateFilterHash();
  1402.         return $this->currentPersisterContext->selectColumnListSql;
  1403.     }
  1405.     /**
  1406.      * Gets the SQL join fragment used when selecting entities from an association.
  1407.      *
  1408.      * @param string             $field
  1409.      * @param AssociationMapping $assoc
  1410.      * @param string             $alias
  1411.      *
  1412.      * @return string
  1413.      */
  1414.     protected function getSelectColumnAssociationSQL($field, $assoc, ClassMetadata $class, $alias = 'r')
  1415.     {
  1416.         if (! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)) {
  1417.             return '';
  1418.         }
  1420.         $columnList    = [];
  1421.         $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
  1422.         $isIdentifier  = isset($assoc['id']) && $assoc['id'] === true;
  1423.         $sqlTableAlias = $this->getSQLTableAlias($class->name, ($alias === 'r' ? '' : $alias));
  1425.         foreach ($assoc['joinColumns'] as $joinColumn) {
  1426.             $quotedColumn     = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1427.             $resultColumnName = $this->getSQLColumnAlias($joinColumn['name']);
  1428.             $type             = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  1430.             $this->currentPersisterContext->rsm->addMetaResult($alias, $resultColumnName, $joinColumn['name'], $isIdentifier, $type);
  1432.             $columnList[] = sprintf('%s.%s AS %s', $sqlTableAlias, $quotedColumn, $resultColumnName);
  1433.         }
  1435.         return implode(', ', $columnList);
  1436.     }
  1438.     /**
  1439.      * Gets the SQL join fragment used when selecting entities from a
  1440.      * many-to-many association.
  1441.      *
  1442.      * @phpstan-param AssociationMapping $manyToMany
  1443.      *
  1444.      * @return string
  1445.      */
  1446.     protected function getSelectManyToManyJoinSQL(array $manyToMany)
  1447.     {
  1448.         $conditions       = [];
  1449.         $association      = $manyToMany;
  1450.         $sourceTableAlias = $this->getSQLTableAlias($this->class->name);
  1452.         if (! $manyToMany['isOwningSide']) {
  1453.             $targetEntity = $this->em->getClassMetadata($manyToMany['targetEntity']);
  1454.             $association  = $targetEntity->associationMappings[$manyToMany['mappedBy']];
  1455.         }
  1457.         $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  1458.         $joinColumns   = $manyToMany['isOwningSide']
  1459.             ? $association['joinTable']['inverseJoinColumns']
  1460.             : $association['joinTable']['joinColumns'];
  1462.         foreach ($joinColumns as $joinColumn) {
  1463.             $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1464.             $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1465.             $conditions[]       = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableName . '.' . $quotedSourceColumn;
  1466.         }
  1468.         return ' INNER JOIN ' . $joinTableName . ' ON ' . implode(' AND ', $conditions);
  1469.     }
  1471.     /**
  1472.      * {@inheritDoc}
  1473.      */
  1474.     public function getInsertSQL()
  1475.     {
  1476.         if ($this->insertSql !== null) {
  1477.             return $this->insertSql;
  1478.         }
  1480.         $columns   = $this->getInsertColumnList();
  1481.         $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1483.         if (empty($columns)) {
  1484.             $identityColumn  = $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class, $this->platform);
  1485.             $this->insertSql = $this->platform->getEmptyIdentityInsertSQL($tableName, $identityColumn);
  1487.             return $this->insertSql;
  1488.         }
  1490.         $values  = [];
  1491.         $columns = array_unique($columns);
  1493.         foreach ($columns as $column) {
  1494.             $placeholder = '?';
  1496.             if (
  1497.                 isset($this->class->fieldNames[$column])
  1498.                 && isset($this->columnTypes[$this->class->fieldNames[$column]])
  1499.                 && isset($this->class->fieldMappings[$this->class->fieldNames[$column]]['requireSQLConversion'])
  1500.             ) {
  1501.                 $type        = Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
  1502.                 $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  1503.             }
  1505.             $values[] = $placeholder;
  1506.         }
  1508.         $columns = implode(', ', $columns);
  1509.         $values  = implode(', ', $values);
  1511.         $this->insertSql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tableName, $columns, $values);
  1513.         return $this->insertSql;
  1514.     }
  1516.     /**
  1517.      * Gets the list of columns to put in the INSERT SQL statement.
  1518.      *
  1519.      * Subclasses should override this method to alter or change the list of
  1520.      * columns placed in the INSERT statements used by the persister.
  1521.      *
  1522.      * @return string[] The list of columns.
  1523.      * @phpstan-return list<string>
  1524.      */
  1525.     protected function getInsertColumnList()
  1526.     {
  1527.         $columns = [];
  1529.         foreach ($this->class->reflFields as $name => $field) {
  1530.             if ($this->class->isVersioned && $this->class->versionField === $name) {
  1531.                 continue;
  1532.             }
  1534.             if (isset($this->class->embeddedClasses[$name])) {
  1535.                 continue;
  1536.             }
  1538.             if (isset($this->class->associationMappings[$name])) {
  1539.                 $assoc = $this->class->associationMappings[$name];
  1541.                 if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  1542.                     foreach ($assoc['joinColumns'] as $joinColumn) {
  1543.                         $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1544.                     }
  1545.                 }
  1547.                 continue;
  1548.             }
  1550.             if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] !== $name) {
  1551.                 if (isset($this->class->fieldMappings[$name]['notInsertable'])) {
  1552.                     continue;
  1553.                 }
  1555.                 $columns[]                = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
  1556.                 $this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
  1557.             }
  1558.         }
  1560.         return $columns;
  1561.     }
  1563.     /**
  1564.      * Gets the SQL snippet of a qualified column name for the given field name.
  1565.      *
  1566.      * @param string        $field The field name.
  1567.      * @param ClassMetadata $class The class that declares this field. The table this class is
  1568.      *                             mapped to must own the column for the given field.
  1569.      * @param string        $alias
  1570.      *
  1571.      * @return string
  1572.      */
  1573.     protected function getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r')
  1574.     {
  1575.         $root         = $alias === 'r' ? '' : $alias;
  1576.         $tableAlias   = $this->getSQLTableAlias($class->name, $root);
  1577.         $fieldMapping = $class->fieldMappings[$field];
  1578.         $sql          = sprintf('%s.%s', $tableAlias, $this->quoteStrategy->getColumnName($field, $class, $this->platform));
  1580.         $columnAlias = null;
  1581.         if ($this->currentPersisterContext->rsm->hasColumnAliasByField($alias, $field)) {
  1582.             $columnAlias = $this->currentPersisterContext->rsm->getColumnAliasByField($alias, $field);
  1583.         }
  1585.         if ($columnAlias === null) {
  1586.             $columnAlias = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1587.         }
  1589.         $this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field);
  1590.         if (! empty($fieldMapping['enumType'])) {
  1591.             $this->currentPersisterContext->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
  1592.         }
  1594.         if (isset($fieldMapping['requireSQLConversion'])) {
  1595.             $type = Type::getType($fieldMapping['type']);
  1596.             $sql  = $type->convertToPHPValueSQL($sql, $this->platform);
  1597.         }
  1599.         return $sql . ' AS ' . $columnAlias;
  1600.     }
  1602.     /**
  1603.      * Gets the SQL table alias for the given class name.
  1604.      *
  1605.      * @param string $className
  1606.      * @param string $assocName
  1607.      *
  1608.      * @return string The SQL table alias.
  1609.      *
  1610.      * @todo Reconsider. Binding table aliases to class names is not such a good idea.
  1611.      */
  1612.     protected function getSQLTableAlias($className, $assocName = '')
  1613.     {
  1614.         if ($assocName) {
  1615.             $className .= '#' . $assocName;
  1616.         }
  1618.         if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
  1619.             return $this->currentPersisterContext->sqlTableAliases[$className];
  1620.         }
  1622.         $tableAlias = 't' . $this->currentPersisterContext->sqlAliasCounter++;
  1624.         $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
  1626.         return $tableAlias;
  1627.     }
  1629.     /**
  1630.      * {@inheritDoc}
  1631.      */
  1632.     public function lock(array $criteria, $lockMode)
  1633.     {
  1634.         $lockSql      = '';
  1635.         $conditionSql = $this->getSelectConditionSQL($criteria);
  1637.         switch ($lockMode) {
  1638.             case LockMode::PESSIMISTIC_READ:
  1639.                 $lockSql = $this->getReadLockSQL($this->platform);
  1641.                 break;
  1642.             case LockMode::PESSIMISTIC_WRITE:
  1643.                 $lockSql = $this->getWriteLockSQL($this->platform);
  1644.                 break;
  1645.         }
  1647.         $lock  = $this->getLockTablesSql($lockMode);
  1648.         $where = ($conditionSql ? ' WHERE ' . $conditionSql : '') . ' ';
  1649.         $sql   = 'SELECT 1 '
  1650.              . $lock
  1651.              . $where
  1652.              . $lockSql;
  1654.         [$params, $types] = $this->expandParameters($criteria);
  1656.         $this->conn->executeQuery($sql, $params, $types);
  1657.     }
  1659.     /**
  1660.      * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
  1661.      *
  1662.      * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants.
  1663.      * @phpstan-param LockMode::*|null $lockMode
  1664.      *
  1665.      * @return string
  1666.      */
  1667.     protected function getLockTablesSql($lockMode)
  1668.     {
  1669.         if ($lockMode === null) {
  1670.             Deprecation::trigger(
  1671.                 'doctrine/orm',
  1672.                 'https://github.com/doctrine/orm/pull/9466',
  1673.                 'Passing null as argument to %s is deprecated, pass LockMode::NONE instead.',
  1674.                 __METHOD__
  1675.             );
  1677.             $lockMode = LockMode::NONE;
  1678.         }
  1680.         return $this->platform->appendLockHint(
  1681.             'FROM '
  1682.             . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
  1683.             . $this->getSQLTableAlias($this->class->name),
  1684.             $lockMode
  1685.         );
  1686.     }
  1688.     /**
  1689.      * Gets the Select Where Condition from a Criteria object.
  1690.      *
  1691.      * @return string
  1692.      */
  1693.     protected function getSelectConditionCriteriaSQL(Criteria $criteria)
  1694.     {
  1695.         $expression = $criteria->getWhereExpression();
  1697.         if ($expression === null) {
  1698.             return '';
  1699.         }
  1701.         $visitor = new SqlExpressionVisitor($this, $this->class);
  1703.         return $visitor->dispatch($expression);
  1704.     }
  1706.     /**
  1707.      * {@inheritDoc}
  1708.      */
  1709.     public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
  1710.     {
  1711.         $selectedColumns = [];
  1712.         $columns         = $this->getSelectConditionStatementColumnSQL($field, $assoc);
  1714.         if (count($columns) > 1 && $comparison === Comparison::IN) {
  1715.             /*
  1716.              *  @todo try to support multi-column IN expressions.
  1717.              *  Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
  1718.              */
  1719.             throw CantUseInOperatorOnCompositeKeys::create();
  1720.         }
  1722.         foreach ($columns as $column) {
  1723.             $placeholder = '?';
  1725.             if (isset($this->class->fieldMappings[$field]['requireSQLConversion'])) {
  1726.                 $type        = Type::getType($this->class->fieldMappings[$field]['type']);
  1727.                 $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->platform);
  1728.             }
  1730.             if ($comparison !== null) {
  1731.                 // special case null value handling
  1732.                 if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && $value === null) {
  1733.                     $selectedColumns[] = $column . ' IS NULL';
  1735.                     continue;
  1736.                 }
  1738.                 if ($comparison === Comparison::NEQ && $value === null) {
  1739.                     $selectedColumns[] = $column . ' IS NOT NULL';
  1741.                     continue;
  1742.                 }
  1744.                 $selectedColumns[] = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
  1746.                 continue;
  1747.             }
  1749.             if (is_array($value)) {
  1750.                 $in = sprintf('%s IN (%s)', $column, $placeholder);
  1752.                 if (array_search(null, $value, true) !== false) {
  1753.                     $selectedColumns[] = sprintf('(%s OR %s IS NULL)', $in, $column);
  1755.                     continue;
  1756.                 }
  1758.                 $selectedColumns[] = $in;
  1760.                 continue;
  1761.             }
  1763.             if ($value === null) {
  1764.                 $selectedColumns[] = sprintf('%s IS NULL', $column);
  1766.                 continue;
  1767.             }
  1769.             $selectedColumns[] = sprintf('%s = %s', $column, $placeholder);
  1770.         }
  1772.         return implode(' AND ', $selectedColumns);
  1773.     }
  1775.     /**
  1776.      * Builds the left-hand-side of a where condition statement.
  1777.      *
  1778.      * @phpstan-param AssociationMapping|null $assoc
  1779.      *
  1780.      * @return string[]
  1781.      * @phpstan-return list<string>
  1782.      *
  1783.      * @throws InvalidFindByCall
  1784.      * @throws UnrecognizedField
  1785.      */
  1786.     private function getSelectConditionStatementColumnSQL(
  1787.         string $field,
  1788.         ?array $assoc = null
  1789.     ): array {
  1790.         if (isset($this->class->fieldMappings[$field])) {
  1791.             $className = $this->class->fieldMappings[$field]['inherited'] ?? $this->class->name;
  1793.             return [$this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getColumnName($field, $this->class, $this->platform)];
  1794.         }
  1796.         if (isset($this->class->associationMappings[$field])) {
  1797.             $association = $this->class->associationMappings[$field];
  1798.             // Many-To-Many requires join table check for joinColumn
  1799.             $columns = [];
  1800.             $class   = $this->class;
  1802.             if ($association['type'] === ClassMetadata::MANY_TO_MANY) {
  1803.                 if (! $association['isOwningSide']) {
  1804.                     $association = $assoc;
  1805.                 }
  1807.                 $joinTableName = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1808.                 $joinColumns   = $assoc['isOwningSide']
  1809.                     ? $association['joinTable']['joinColumns']
  1810.                     : $association['joinTable']['inverseJoinColumns'];
  1812.                 foreach ($joinColumns as $joinColumn) {
  1813.                     $columns[] = $joinTableName . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1814.                 }
  1815.             } else {
  1816.                 if (! $association['isOwningSide']) {
  1817.                     throw InvalidFindByCall::fromInverseSideUsage(
  1818.                         $this->class->name,
  1819.                         $field
  1820.                     );
  1821.                 }
  1823.                 $className = $association['inherited'] ?? $this->class->name;
  1825.                 foreach ($association['joinColumns'] as $joinColumn) {
  1826.                     $columns[] = $this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1827.                 }
  1828.             }
  1830.             return $columns;
  1831.         }
  1833.         if ($assoc !== null && ! str_contains($field, ' ') && ! str_contains($field, '(')) {
  1834.             // very careless developers could potentially open up this normally hidden api for userland attacks,
  1835.             // therefore checking for spaces and function calls which are not allowed.
  1837.             // found a join column condition, not really a "field"
  1838.             return [$field];
  1839.         }
  1841.         throw UnrecognizedField::byFullyQualifiedName($this->class->name, $field);
  1842.     }
  1844.     /**
  1845.      * Gets the conditional SQL fragment used in the WHERE clause when selecting
  1846.      * entities in this persister.
  1847.      *
  1848.      * Subclasses are supposed to override this method if they intend to change
  1849.      * or alter the criteria by which entities are selected.
  1850.      *
  1851.      * @param AssociationMapping|null $assoc
  1852.      * @phpstan-param array<string, mixed> $criteria
  1853.      * @phpstan-param array<string, mixed>|null $assoc
  1854.      *
  1855.      * @return string
  1856.      */
  1857.     protected function getSelectConditionSQL(array $criteria, $assoc = null)
  1858.     {
  1859.         $conditions = [];
  1861.         foreach ($criteria as $field => $value) {
  1862.             $conditions[] = $this->getSelectConditionStatementSQL($field, $value, $assoc);
  1863.         }
  1865.         return implode(' AND ', $conditions);
  1866.     }
  1868.     /**
  1869.      * {@inheritDoc}
  1870.      */
  1871.     public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1872.     {
  1873.         $this->switchPersisterContext($offset, $limit);
  1875.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity, $offset, $limit);
  1877.         return $this->loadArrayFromResult($assoc, $stmt);
  1878.     }
  1880.     /**
  1881.      * {@inheritDoc}
  1882.      */
  1883.     public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1884.     {
  1885.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity);
  1887.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1888.     }
  1890.     /**
  1891.      * Builds criteria and execute SQL statement to fetch the one to many entities from.
  1892.      *
  1893.      * @param object $sourceEntity
  1894.      * @phpstan-param AssociationMapping $assoc
  1895.      */
  1896.     private function getOneToManyStatement(
  1897.         array $assoc,
  1898.         $sourceEntity,
  1899.         ?int $offset = null,
  1900.         ?int $limit = null
  1901.     ): Result {
  1902.         $this->switchPersisterContext($offset, $limit);
  1904.         $criteria    = [];
  1905.         $parameters  = [];
  1906.         $owningAssoc = $this->class->associationMappings[$assoc['mappedBy']];
  1907.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1908.         $tableAlias  = $this->getSQLTableAlias($owningAssoc['inherited'] ?? $this->class->name);
  1910.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  1911.             if ($sourceClass->containsForeignIdentifier) {
  1912.                 $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1913.                 $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1915.                 if (isset($sourceClass->associationMappings[$field])) {
  1916.                     $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1917.                     $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1918.                 }
  1920.                 $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1921.                 $parameters[]                                   = [
  1922.                     'value' => $value,
  1923.                     'field' => $field,
  1924.                     'class' => $sourceClass,
  1925.                 ];
  1927.                 continue;
  1928.             }
  1930.             $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1931.             $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1933.             $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1934.             $parameters[]                                   = [
  1935.                 'value' => $value,
  1936.                 'field' => $field,
  1937.                 'class' => $sourceClass,
  1938.             ];
  1939.         }
  1941.         $sql              = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1942.         [$params, $types] = $this->expandToManyParameters($parameters);
  1944.         return $this->conn->executeQuery($sql, $params, $types);
  1945.     }
  1947.     /**
  1948.      * {@inheritDoc}
  1949.      */
  1950.     public function expandParameters($criteria)
  1951.     {
  1952.         $params = [];
  1953.         $types  = [];
  1955.         foreach ($criteria as $field => $value) {
  1956.             if ($value === null) {
  1957.                 continue; // skip null values.
  1958.             }
  1960.             $types  = array_merge($types, $this->getTypes($field, $value, $this->class));
  1961.             $params = array_merge($params, $this->getValues($value));
  1962.         }
  1964.         return [$params, $types];
  1965.     }
  1967.     /**
  1968.      * Expands the parameters from the given criteria and use the correct binding types if found,
  1969.      * specialized for OneToMany or ManyToMany associations.
  1970.      *
  1971.      * @param mixed[][] $criteria an array of arrays containing following:
  1972.      *                             - field to which each criterion will be bound
  1973.      *                             - value to be bound
  1974.      *                             - class to which the field belongs to
  1975.      *
  1976.      * @return mixed[][]
  1977.      * @phpstan-return array{0: array, 1: list<int|string|null>}
  1978.      */
  1979.     private function expandToManyParameters(array $criteria): array
  1980.     {
  1981.         $params = [];
  1982.         $types  = [];
  1984.         foreach ($criteria as $criterion) {
  1985.             if ($criterion['value'] === null) {
  1986.                 continue; // skip null values.
  1987.             }
  1989.             $types  = array_merge($types, $this->getTypes($criterion['field'], $criterion['value'], $criterion['class']));
  1990.             $params = array_merge($params, $this->getValues($criterion['value']));
  1991.         }
  1993.         return [$params, $types];
  1994.     }
  1996.     /**
  1997.      * Infers field types to be used by parameter type casting.
  1998.      *
  1999.      * @param mixed $value
  2000.      *
  2001.      * @return int[]|null[]|string[]
  2002.      * @phpstan-return list<int|string|null>
  2003.      *
  2004.      * @throws QueryException
  2005.      */
  2006.     private function getTypes(string $field, $value, ClassMetadata $class): array
  2007.     {
  2008.         $types = [];
  2010.         switch (true) {
  2011.             case isset($class->fieldMappings[$field]):
  2012.                 $types = array_merge($types, [$class->fieldMappings[$field]['type']]);
  2013.                 break;
  2015.             case isset($class->associationMappings[$field]):
  2016.                 $assoc = $class->associationMappings[$field];
  2017.                 $class = $this->em->getClassMetadata($assoc['targetEntity']);
  2019.                 if (! $assoc['isOwningSide']) {
  2020.                     $assoc = $class->associationMappings[$assoc['mappedBy']];
  2021.                     $class = $this->em->getClassMetadata($assoc['targetEntity']);
  2022.                 }
  2024.                 $columns = $assoc['type'] === ClassMetadata::MANY_TO_MANY
  2025.                     ? $assoc['relationToTargetKeyColumns']
  2026.                     : $assoc['sourceToTargetKeyColumns'];
  2028.                 foreach ($columns as $column) {
  2029.                     $types[] = PersisterHelper::getTypeOfColumn($column, $class, $this->em);
  2030.                 }
  2032.                 break;
  2034.             default:
  2035.                 $types[] = null;
  2036.                 break;
  2037.         }
  2039.         if (is_array($value)) {
  2040.             return array_map(static function ($type) {
  2041.                 $type = Type::getType($type);
  2043.                 return $type->getBindingType() + Connection::ARRAY_PARAM_OFFSET;
  2044.             }, $types);
  2045.         }
  2047.         return $types;
  2048.     }
  2050.     /**
  2051.      * Retrieves the parameters that identifies a value.
  2052.      *
  2053.      * @param mixed $value
  2054.      *
  2055.      * @return mixed[]
  2056.      */
  2057.     private function getValues($value): array
  2058.     {
  2059.         if (is_array($value)) {
  2060.             $newValue = [];
  2062.             foreach ($value as $itemValue) {
  2063.                 $newValue = array_merge($newValue, $this->getValues($itemValue));
  2064.             }
  2066.             return [$newValue];
  2067.         }
  2069.         return $this->getIndividualValue($value);
  2070.     }
  2072.     /**
  2073.      * Retrieves an individual parameter value.
  2074.      *
  2075.      * @param mixed $value
  2076.      *
  2077.      * @phpstan-return list<mixed>
  2078.      */
  2079.     private function getIndividualValue($value): array
  2080.     {
  2081.         if (! is_object($value)) {
  2082.             return [$value];
  2083.         }
  2085.         if ($value instanceof BackedEnum) {
  2086.             return [$value->value];
  2087.         }
  2089.         $valueClass = DefaultProxyClassNameResolver::getClass($value);
  2091.         if ($this->em->getMetadataFactory()->isTransient($valueClass)) {
  2092.             return [$value];
  2093.         }
  2095.         $class = $this->em->getClassMetadata($valueClass);
  2097.         if ($class->isIdentifierComposite) {
  2098.             $newValue = [];
  2100.             foreach ($class->getIdentifierValues($value) as $innerValue) {
  2101.                 $newValue = array_merge($newValue, $this->getValues($innerValue));
  2102.             }
  2104.             return $newValue;
  2105.         }
  2107.         return [$this->em->getUnitOfWork()->getSingleIdentifierValue($value)];
  2108.     }
  2110.     /**
  2111.      * {@inheritDoc}
  2112.      */
  2113.     public function exists($entity, ?Criteria $extraConditions = null)
  2114.     {
  2115.         $criteria = $this->class->getIdentifierValues($entity);
  2117.         if (! $criteria) {
  2118.             return false;
  2119.         }
  2121.         $alias = $this->getSQLTableAlias($this->class->name);
  2123.         $sql = 'SELECT 1 '
  2124.              . $this->getLockTablesSql(LockMode::NONE)
  2125.              . ' WHERE ' . $this->getSelectConditionSQL($criteria);
  2127.         [$params, $types] = $this->expandParameters($criteria);
  2129.         if ($extraConditions !== null) {
  2130.             $sql                             .= ' AND ' . $this->getSelectConditionCriteriaSQL($extraConditions);
  2131.             [$criteriaParams, $criteriaTypes] = $this->expandCriteriaParameters($extraConditions);
  2133.             $params = array_merge($params, $criteriaParams);
  2134.             $types  = array_merge($types, $criteriaTypes);
  2135.         }
  2137.         $filterSql = $this->generateFilterConditionSQL($this->class, $alias);
  2138.         if ($filterSql) {
  2139.             $sql .= ' AND ' . $filterSql;
  2140.         }
  2142.         return (bool) $this->conn->fetchOne($sql, $params, $types);
  2143.     }
  2145.     /**
  2146.      * Generates the appropriate join SQL for the given join column.
  2147.      *
  2148.      * @param array[] $joinColumns The join columns definition of an association.
  2149.      * @phpstan-param array<array<string, mixed>> $joinColumns
  2150.      *
  2151.      * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
  2152.      */
  2153.     protected function getJoinSQLForJoinColumns($joinColumns)
  2154.     {
  2155.         // if one of the join columns is nullable, return left join
  2156.         foreach ($joinColumns as $joinColumn) {
  2157.             if (! isset($joinColumn['nullable']) || $joinColumn['nullable']) {
  2158.                 return 'LEFT JOIN';
  2159.             }
  2160.         }
  2162.         return 'INNER JOIN';
  2163.     }
  2165.     /**
  2166.      * @param string $columnName
  2167.      *
  2168.      * @return string
  2169.      */
  2170.     public function getSQLColumnAlias($columnName)
  2171.     {
  2172.         return $this->quoteStrategy->getColumnAlias($columnName, $this->currentPersisterContext->sqlAliasCounter++, $this->platform);
  2173.     }
  2175.     /**
  2176.      * Generates the filter SQL for a given entity and table alias.
  2177.      *
  2178.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  2179.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  2180.      *
  2181.      * @return string The SQL query part to add to a query.
  2182.      */
  2183.     protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
  2184.     {
  2185.         $filterClauses = [];
  2187.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  2188.             $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  2189.             if ($filterExpr !== '') {
  2190.                 $filterClauses[] = '(' . $filterExpr . ')';
  2191.             }
  2192.         }
  2194.         $sql = implode(' AND ', $filterClauses);
  2196.         return $sql ? '(' . $sql . ')' : ''; // Wrap again to avoid "X or Y and FilterConditionSQL"
  2197.     }
  2199.     /**
  2200.      * Switches persister context according to current query offset/limits
  2201.      *
  2202.      * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
  2203.      *
  2204.      * @param int|null $offset
  2205.      * @param int|null $limit
  2206.      *
  2207.      * @return void
  2208.      */
  2209.     protected function switchPersisterContext($offset, $limit)
  2210.     {
  2211.         if ($offset === null && $limit === null) {
  2212.             $this->currentPersisterContext = $this->noLimitsContext;
  2214.             return;
  2215.         }
  2217.         $this->currentPersisterContext = $this->limitsHandlingContext;
  2218.     }
  2220.     /**
  2221.      * @return string[]
  2222.      * @phpstan-return list<string>
  2223.      */
  2224.     protected function getClassIdentifiersTypes(ClassMetadata $class): array
  2225.     {
  2226.         $entityManager = $this->em;
  2228.         return array_map(
  2229.             static function ($fieldName) use ($class, $entityManager): string {
  2230.                 $types = PersisterHelper::getTypeOfField($fieldName, $class, $entityManager);
  2231.                 assert(isset($types[0]));
  2233.                 return $types[0];
  2234.             },
  2235.             $class->identifier
  2236.         );
  2237.     }
  2238. }