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

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ORM\Persisters\Entity;
  22. use Doctrine\Common\Collections\Criteria;
  23. use Doctrine\Common\Collections\Expr\Comparison;
  24. use Doctrine\Common\Util\ClassUtils;
  25. use Doctrine\DBAL\Connection;
  26. use Doctrine\DBAL\LockMode;
  27. use Doctrine\DBAL\Types\Type;
  28. use Doctrine\ORM\EntityManagerInterface;
  29. use Doctrine\ORM\Mapping\ClassMetadata;
  30. use Doctrine\ORM\Mapping\MappingException;
  31. use Doctrine\ORM\OptimisticLockException;
  32. use Doctrine\ORM\ORMException;
  33. use Doctrine\ORM\PersistentCollection;
  34. use Doctrine\ORM\Persisters\SqlExpressionVisitor;
  35. use Doctrine\ORM\Persisters\SqlValueVisitor;
  36. use Doctrine\ORM\Query;
  37. use Doctrine\ORM\UnitOfWork;
  38. use Doctrine\ORM\Utility\IdentifierFlattener;
  39. use Doctrine\ORM\Utility\PersisterHelper;
  40. use function array_map;
  41. use function array_merge;
  42. use function assert;
  43. use function reset;
  45. /**
  46.  * A BasicEntityPersister maps an entity to a single table in a relational database.
  47.  *
  48.  * A persister is always responsible for a single entity type.
  49.  *
  50.  * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
  51.  * state of entities onto a relational database when the UnitOfWork is committed,
  52.  * as well as for basic querying of entities and their associations (not DQL).
  53.  *
  54.  * The persisting operations that are invoked during a commit of a UnitOfWork to
  55.  * persist the persistent entity state are:
  56.  *
  57.  *   - {@link addInsert} : To schedule an entity for insertion.
  58.  *   - {@link executeInserts} : To execute all scheduled insertions.
  59.  *   - {@link update} : To update the persistent state of an entity.
  60.  *   - {@link delete} : To delete the persistent state of an entity.
  61.  *
  62.  * As can be seen from the above list, insertions are batched and executed all at once
  63.  * for increased efficiency.
  64.  *
  65.  * The querying operations invoked during a UnitOfWork, either through direct find
  66.  * requests or lazy-loading, are the following:
  67.  *
  68.  *   - {@link load} : Loads (the state of) a single, managed entity.
  69.  *   - {@link loadAll} : Loads multiple, managed entities.
  70.  *   - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
  71.  *   - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
  72.  *   - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
  73.  *
  74.  * The BasicEntityPersister implementation provides the default behavior for
  75.  * persisting and querying entities that are mapped to a single database table.
  76.  *
  77.  * Subclasses can be created to provide custom persisting and querying strategies,
  78.  * i.e. spanning multiple tables.
  79.  *
  80.  * @author Roman Borschel <roman@code-factory.org>
  81.  * @author Giorgio Sironi <piccoloprincipeazzurro@gmail.com>
  82.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  83.  * @author Alexander <iam.asm89@gmail.com>
  84.  * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
  85.  * @author Rob Caiger <rob@clocal.co.uk>
  86.  * @since 2.0
  87.  */
  88. class BasicEntityPersister implements EntityPersister
  89. {
  90.     /**
  91.      * @var array
  92.      */
  93.     static private $comparisonMap = [
  94.         Comparison::EQ          => '= %s',
  95.         Comparison::NEQ         => '!= %s',
  96.         Comparison::GT          => '> %s',
  97.         Comparison::GTE         => '>= %s',
  98.         Comparison::LT          => '< %s',
  99.         Comparison::LTE         => '<= %s',
  100.         Comparison::IN          => 'IN (%s)',
  101.         Comparison::NIN         => 'NOT IN (%s)',
  102.         Comparison::CONTAINS    => 'LIKE %s',
  103.         Comparison::STARTS_WITH => 'LIKE %s',
  104.         Comparison::ENDS_WITH   => 'LIKE %s',
  105.     ];
  107.     /**
  108.      * Metadata object that describes the mapping of the mapped entity class.
  109.      *
  110.      * @var \Doctrine\ORM\Mapping\ClassMetadata
  111.      */
  112.     protected $class;
  114.     /**
  115.      * The underlying DBAL Connection of the used EntityManager.
  116.      *
  117.      * @var \Doctrine\DBAL\Connection $conn
  118.      */
  119.     protected $conn;
  121.     /**
  122.      * The database platform.
  123.      *
  124.      * @var \Doctrine\DBAL\Platforms\AbstractPlatform
  125.      */
  126.     protected $platform;
  128.     /**
  129.      * The EntityManager instance.
  130.      *
  131.      * @var EntityManagerInterface
  132.      */
  133.     protected $em;
  135.     /**
  136.      * Queued inserts.
  137.      *
  138.      * @var array
  139.      */
  140.     protected $queuedInserts = [];
  142.     /**
  143.      * The map of column names to DBAL mapping types of all prepared columns used
  144.      * when INSERTing or UPDATEing an entity.
  145.      *
  146.      * @var array
  147.      *
  148.      * @see prepareInsertData($entity)
  149.      * @see prepareUpdateData($entity)
  150.      */
  151.     protected $columnTypes = [];
  153.     /**
  154.      * The map of quoted column names.
  155.      *
  156.      * @var array
  157.      *
  158.      * @see prepareInsertData($entity)
  159.      * @see prepareUpdateData($entity)
  160.      */
  161.     protected $quotedColumns = [];
  163.     /**
  164.      * The INSERT SQL statement used for entities handled by this persister.
  165.      * This SQL is only generated once per request, if at all.
  166.      *
  167.      * @var string
  168.      */
  169.     private $insertSql;
  171.     /**
  172.      * The quote strategy.
  173.      *
  174.      * @var \Doctrine\ORM\Mapping\QuoteStrategy
  175.      */
  176.     protected $quoteStrategy;
  178.     /**
  179.      * The IdentifierFlattener used for manipulating identifiers
  180.      *
  181.      * @var \Doctrine\ORM\Utility\IdentifierFlattener
  182.      */
  183.     private $identifierFlattener;
  185.     /**
  186.      * @var CachedPersisterContext
  187.      */
  188.     protected $currentPersisterContext;
  190.     /**
  191.      * @var CachedPersisterContext
  192.      */
  193.     private $limitsHandlingContext;
  195.     /**
  196.      * @var CachedPersisterContext
  197.      */
  198.     private $noLimitsContext;
  200.     /**
  201.      * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
  202.      * and persists instances of the class described by the given ClassMetadata descriptor.
  203.      *
  204.      * @param EntityManagerInterface $em
  205.      * @param ClassMetadata          $class
  206.      */
  207.     public function __construct(EntityManagerInterface $em, ClassMetadata $class)
  208.     {
  209.         $this->em                    = $em;
  210.         $this->class                 = $class;
  211.         $this->conn                  = $em->getConnection();
  212.         $this->platform              = $this->conn->getDatabasePlatform();
  213.         $this->quoteStrategy         = $em->getConfiguration()->getQuoteStrategy();
  214.         $this->identifierFlattener   = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
  215.         $this->noLimitsContext       = $this->currentPersisterContext = new CachedPersisterContext(
  216.             $class,
  217.             new Query\ResultSetMapping(),
  218.             false
  219.         );
  220.         $this->limitsHandlingContext = new CachedPersisterContext(
  221.             $class,
  222.             new Query\ResultSetMapping(),
  223.             true
  224.         );
  225.     }
  227.     /**
  228.      * {@inheritdoc}
  229.      */
  230.     public function getClassMetadata()
  231.     {
  232.         return $this->class;
  233.     }
  235.     /**
  236.      * {@inheritdoc}
  237.      */
  238.     public function getResultSetMapping()
  239.     {
  240.         return $this->currentPersisterContext->rsm;
  241.     }
  243.     /**
  244.      * {@inheritdoc}
  245.      */
  246.     public function addInsert($entity)
  247.     {
  248.         $this->queuedInserts[spl_object_hash($entity)] = $entity;
  249.     }
  251.     /**
  252.      * {@inheritdoc}
  253.      */
  254.     public function getInserts()
  255.     {
  256.         return $this->queuedInserts;
  257.     }
  259.     /**
  260.      * {@inheritdoc}
  261.      */
  262.     public function executeInserts()
  263.     {
  264.         if ( ! $this->queuedInserts) {
  265.             return [];
  266.         }
  268.         $postInsertIds  = [];
  269.         $idGenerator    = $this->class->idGenerator;
  270.         $isPostInsertId = $idGenerator->isPostInsertGenerator();
  272.         $stmt       = $this->conn->prepare($this->getInsertSQL());
  273.         $tableName  = $this->class->getTableName();
  275.         foreach ($this->queuedInserts as $entity) {
  276.             $insertData = $this->prepareInsertData($entity);
  278.             if (isset($insertData[$tableName])) {
  279.                 $paramIndex = 1;
  281.                 foreach ($insertData[$tableName] as $column => $value) {
  282.                     $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$column]);
  283.                 }
  284.             }
  286.             $stmt->execute();
  288.             if ($isPostInsertId) {
  289.                 $generatedId = $idGenerator->generate($this->em, $entity);
  290.                 $id = [
  291.                     $this->class->identifier[0] => $generatedId
  292.                 ];
  293.                 $postInsertIds[] = [
  294.                     'generatedId' => $generatedId,
  295.                     'entity' => $entity,
  296.                 ];
  297.             } else {
  298.                 $id = $this->class->getIdentifierValues($entity);
  299.             }
  301.             if ($this->class->isVersioned) {
  302.                 $this->assignDefaultVersionValue($entity, $id);
  303.             }
  304.         }
  306.         $stmt->closeCursor();
  307.         $this->queuedInserts = [];
  309.         return $postInsertIds;
  310.     }
  312.     /**
  313.      * Retrieves the default version value which was created
  314.      * by the preceding INSERT statement and assigns it back in to the
  315.      * entities version field.
  316.      *
  317.      * @param object $entity
  318.      * @param array  $id
  319.      *
  320.      * @return void
  321.      */
  322.     protected function assignDefaultVersionValue($entity, array $id)
  323.     {
  324.         $value = $this->fetchVersionValue($this->class, $id);
  326.         $this->class->setFieldValue($entity, $this->class->versionField, $value);
  327.     }
  329.     /**
  330.      * Fetches the current version value of a versioned entity.
  331.      *
  332.      * @param \Doctrine\ORM\Mapping\ClassMetadata $versionedClass
  333.      * @param array                               $id
  334.      *
  335.      * @return mixed
  336.      */
  337.     protected function fetchVersionValue($versionedClass, array $id)
  338.     {
  339.         $versionField = $versionedClass->versionField;
  340.         $fieldMapping = $versionedClass->fieldMappings[$versionField];
  341.         $tableName    = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
  342.         $identifier   = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
  343.         $columnName   = $this->quoteStrategy->getColumnName($versionField, $versionedClass, $this->platform);
  345.         // FIXME: Order with composite keys might not be correct
  346.         $sql = 'SELECT ' . $columnName
  347.              . ' FROM '  . $tableName
  348.              . ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
  351.         $flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
  353.         $value = $this->conn->fetchColumn(
  354.             $sql,
  355.             array_values($flatId),
  356.             0,
  357.             $this->extractIdentifierTypes($id, $versionedClass)
  358.         );
  360.         return Type::getType($fieldMapping['type'])->convertToPHPValue($value, $this->platform);
  361.     }
  363.     /**
  364.      * @return int[]|null[]|string[]
  365.      *
  366.      * @psalm-return list<int|null|string>
  367.      */
  368.     private function extractIdentifierTypes(array $id, ClassMetadata $versionedClass) : array
  369.     {
  370.         $types = [];
  372.         foreach ($id as $field => $value) {
  373.             $types = array_merge($types, $this->getTypes($field, $value, $versionedClass));
  374.         }
  376.         return $types;
  377.     }
  379.     /**
  380.      * {@inheritdoc}
  381.      */
  382.     public function update($entity)
  383.     {
  384.         $tableName  = $this->class->getTableName();
  385.         $updateData = $this->prepareUpdateData($entity);
  387.         if ( ! isset($updateData[$tableName]) || ! ($data = $updateData[$tableName])) {
  388.             return;
  389.         }
  391.         $isVersioned     = $this->class->isVersioned;
  392.         $quotedTableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  394.         $this->updateTable($entity, $quotedTableName, $data, $isVersioned);
  396.         if ($isVersioned) {
  397.             $id = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  399.             $this->assignDefaultVersionValue($entity, $id);
  400.         }
  401.     }
  403.     /**
  404.      * Performs an UPDATE statement for an entity on a specific table.
  405.      * The UPDATE can optionally be versioned, which requires the entity to have a version field.
  406.      *
  407.      * @param object  $entity          The entity object being updated.
  408.      * @param string  $quotedTableName The quoted name of the table to apply the UPDATE on.
  409.      * @param array   $updateData      The map of columns to update (column => value).
  410.      * @param boolean $versioned       Whether the UPDATE should be versioned.
  411.      *
  412.      * @return void
  413.      *
  414.      * @throws \Doctrine\ORM\ORMException
  415.      * @throws \Doctrine\ORM\OptimisticLockException
  416.      */
  417.     protected final function updateTable($entity, $quotedTableName, array $updateData, $versioned = false)
  418.     {
  419.         $set    = [];
  420.         $types  = [];
  421.         $params = [];
  423.         foreach ($updateData as $columnName => $value) {
  424.             $placeholder = '?';
  425.             $column      = $columnName;
  427.             switch (true) {
  428.                 case isset($this->class->fieldNames[$columnName]):
  429.                     $fieldName  = $this->class->fieldNames[$columnName];
  430.                     $column     = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  432.                     if (isset($this->class->fieldMappings[$fieldName]['requireSQLConversion'])) {
  433.                         $type        = Type::getType($this->columnTypes[$columnName]);
  434.                         $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  435.                     }
  437.                     break;
  439.                 case isset($this->quotedColumns[$columnName]):
  440.                     $column = $this->quotedColumns[$columnName];
  442.                     break;
  443.             }
  445.             $params[]   = $value;
  446.             $set[]      = $column . ' = ' . $placeholder;
  447.             $types[]    = $this->columnTypes[$columnName];
  448.         }
  450.         $where      = [];
  451.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  453.         foreach ($this->class->identifier as $idField) {
  454.             if ( ! isset($this->class->associationMappings[$idField])) {
  455.                 $params[] = $identifier[$idField];
  456.                 $types[]  = $this->class->fieldMappings[$idField]['type'];
  457.                 $where[]  = $this->quoteStrategy->getColumnName($idField, $this->class, $this->platform);
  459.                 continue;
  460.             }
  462.             $params[] = $identifier[$idField];
  463.             $where[]  = $this->quoteStrategy->getJoinColumnName(
  464.                 $this->class->associationMappings[$idField]['joinColumns'][0],
  465.                 $this->class,
  466.                 $this->platform
  467.             );
  469.             $targetMapping = $this->em->getClassMetadata($this->class->associationMappings[$idField]['targetEntity']);
  470.             $targetType    = PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping, $this->em);
  472.             if ($targetType === []) {
  473.                 throw ORMException::unrecognizedField($targetMapping->identifier[0]);
  474.             }
  476.             $types[] = reset($targetType);
  477.         }
  479.         if ($versioned) {
  480.             $versionField       = $this->class->versionField;
  481.             $versionFieldType   = $this->class->fieldMappings[$versionField]['type'];
  482.             $versionColumn      = $this->quoteStrategy->getColumnName($versionField, $this->class, $this->platform);
  484.             $where[]    = $versionColumn;
  485.             $types[]    = $this->class->fieldMappings[$versionField]['type'];
  486.             $params[]   = $this->class->reflFields[$versionField]->getValue($entity);
  488.             switch ($versionFieldType) {
  489.                 case Type::SMALLINT:
  490.                 case Type::INTEGER:
  491.                 case Type::BIGINT:
  492.                     $set[] = $versionColumn . ' = ' . $versionColumn . ' + 1';
  493.                     break;
  495.                 case Type::DATETIME:
  496.                     $set[] = $versionColumn . ' = CURRENT_TIMESTAMP';
  497.                     break;
  498.             }
  499.         }
  501.         $sql = 'UPDATE ' . $quotedTableName
  502.              . ' SET ' . implode(', ', $set)
  503.              . ' WHERE ' . implode(' = ? AND ', $where) . ' = ?';
  505.         $result = $this->conn->executeUpdate($sql, $params, $types);
  507.         if ($versioned && ! $result) {
  508.             throw OptimisticLockException::lockFailed($entity);
  509.         }
  510.     }
  512.     /**
  513.      * @todo Add check for platform if it supports foreign keys/cascading.
  514.      *
  515.      * @param array $identifier
  516.      *
  517.      * @return void
  518.      */
  519.     protected function deleteJoinTableRecords($identifier)
  520.     {
  521.         foreach ($this->class->associationMappings as $mapping) {
  522.             if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY) {
  523.                 continue;
  524.             }
  526.             // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
  527.             // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
  528.             $selfReferential = ($mapping['targetEntity'] == $mapping['sourceEntity']);
  529.             $class           = $this->class;
  530.             $association     = $mapping;
  531.             $otherColumns    = [];
  532.             $otherKeys       = [];
  533.             $keys            = [];
  535.             if ( ! $mapping['isOwningSide']) {
  536.                 $class       = $this->em->getClassMetadata($mapping['targetEntity']);
  537.                 $association = $class->associationMappings[$mapping['mappedBy']];
  538.             }
  540.             $joinColumns = $mapping['isOwningSide']
  541.                 ? $association['joinTable']['joinColumns']
  542.                 : $association['joinTable']['inverseJoinColumns'];
  545.             if ($selfReferential) {
  546.                 $otherColumns = (! $mapping['isOwningSide'])
  547.                     ? $association['joinTable']['joinColumns']
  548.                     : $association['joinTable']['inverseJoinColumns'];
  549.             }
  551.             foreach ($joinColumns as $joinColumn) {
  552.                 $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  553.             }
  555.             foreach ($otherColumns as $joinColumn) {
  556.                 $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  557.             }
  559.             if (isset($mapping['isOnDeleteCascade'])) {
  560.                 continue;
  561.             }
  563.             $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  565.             $this->conn->delete($joinTableName, array_combine($keys, $identifier));
  567.             if ($selfReferential) {
  568.                 $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier));
  569.             }
  570.         }
  571.     }
  573.     /**
  574.      * {@inheritdoc}
  575.      */
  576.     public function delete($entity)
  577.     {
  578.         $class      = $this->class;
  579.         $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  580.         $tableName  = $this->quoteStrategy->getTableName($class, $this->platform);
  581.         $idColumns  = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform);
  582.         $id         = array_combine($idColumns, $identifier);
  583.         $types      = $this->getClassIdentifiersTypes($class);
  585.         $this->deleteJoinTableRecords($identifier);
  587.         return (bool) $this->conn->delete($tableName, $id, $types);
  588.     }
  590.     /**
  591.      * Prepares the changeset of an entity for database insertion (UPDATE).
  592.      *
  593.      * The changeset is obtained from the currently running UnitOfWork.
  594.      *
  595.      * During this preparation the array that is passed as the second parameter is filled with
  596.      * <columnName> => <value> pairs, grouped by table name.
  597.      *
  598.      * Example:
  599.      * <code>
  600.      * array(
  601.      *    'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
  602.      *    'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
  603.      *    ...
  604.      * )
  605.      * </code>
  606.      *
  607.      * @param object $entity The entity for which to prepare the data.
  608.      *
  609.      * @return mixed[][] The prepared data.
  610.      *
  611.      * @psalm-return array<string, array<array-key, mixed|null>>
  612.      */
  613.     protected function prepareUpdateData($entity)
  614.     {
  615.         $versionField = null;
  616.         $result       = [];
  617.         $uow          = $this->em->getUnitOfWork();
  619.         if (($versioned = $this->class->isVersioned) != false) {
  620.             $versionField = $this->class->versionField;
  621.         }
  623.         foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
  624.             if (isset($versionField) && $versionField == $field) {
  625.                 continue;
  626.             }
  628.             if (isset($this->class->embeddedClasses[$field])) {
  629.                 continue;
  630.             }
  632.             $newVal = $change[1];
  634.             if ( ! isset($this->class->associationMappings[$field])) {
  635.                 $fieldMapping = $this->class->fieldMappings[$field];
  636.                 $columnName   = $fieldMapping['columnName'];
  638.                 $this->columnTypes[$columnName] = $fieldMapping['type'];
  640.                 $result[$this->getOwningTable($field)][$columnName] = $newVal;
  642.                 continue;
  643.             }
  645.             $assoc = $this->class->associationMappings[$field];
  647.             // Only owning side of x-1 associations can have a FK column.
  648.             if ( ! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
  649.                 continue;
  650.             }
  652.             if ($newVal !== null) {
  653.                 $oid = spl_object_hash($newVal);
  655.                 if (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal)) {
  656.                     // The associated entity $newVal is not yet persisted, so we must
  657.                     // set $newVal = null, in order to insert a null value and schedule an
  658.                     // extra update on the UnitOfWork.
  659.                     $uow->scheduleExtraUpdate($entity, [$field => [null, $newVal]]);
  661.                     $newVal = null;
  662.                 }
  663.             }
  665.             $newValId = null;
  667.             if ($newVal !== null) {
  668.                 $newValId = $uow->getEntityIdentifier($newVal);
  669.             }
  671.             $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  672.             $owningTable = $this->getOwningTable($field);
  674.             foreach ($assoc['joinColumns'] as $joinColumn) {
  675.                 $sourceColumn = $joinColumn['name'];
  676.                 $targetColumn = $joinColumn['referencedColumnName'];
  677.                 $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  678. //MC 20210603 DEBUT Ajouté pour resoudre le problème de champs inexistants dû au type JSONB explication dans le fichier Modifications apportées à Symfony.docx
  679.                 if (strpos($sourceColumn, '->>')) {
  680.                     continue;
  681.                 }
  682. //MC 20210603 FIN
  684.                 $this->quotedColumns[$sourceColumn]  = $quotedColumn;
  685.                 $this->columnTypes[$sourceColumn]    = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
  686. // LG 20230821 début
  687. //                $result[$owningTable][$sourceColumn] = $newValId
  688. //                     ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
  689. //                     : null;
  690. // LG 20241003 old                if ($change[1] === $change[0] && $result[$owningTable][$sourceColumn]) {
  691.                 if ($change[1] === $change[0] && isset($result[$owningTable][$sourceColumn]) && $result[$owningTable][$sourceColumn]) {
  692.                     // Il n'a a pas de changement ou le changement a été annulé dans le champ contenant l'entité étrangère
  693.                     // Par exemple, dans le cas des matières, quand on crée une nouvelle matière en utilisant une AB préexistante
  694.                         // , Doctrine veut faire un Insert de la nouvelle matière
  695.                         // -> dans DefaultController.addAction, on met à null matiere.actibase, mais on assigne la valeur de matiere.iactibase
  696.                     // Ne rien changer : l'id clé étrangère est déja placée dans le tableau
  697.                     $toto = 0 ;
  698.                 } else {
  699.                     $result[$owningTable][$sourceColumn] = $newValId
  700.                         ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
  701.                         : null;
  702.                 }
  703. // LG 20230821 fin
  704.             }
  705.         }
  707.         return $result;
  708.     }
  710.     /**
  711.      * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
  712.      * The changeset of the entity is obtained from the currently running UnitOfWork.
  713.      *
  714.      * The default insert data preparation is the same as for updates.
  715.      *
  716.      * @param object $entity The entity for which to prepare the data.
  717.      *
  718.      * @return mixed[][] The prepared data for the tables to update.
  719.      *
  720.      * @see prepareUpdateData
  721.      *
  722.      * @psalm-return array<string, mixed[]>
  723.      */
  724.     protected function prepareInsertData($entity)
  725.     {
  726.         return $this->prepareUpdateData($entity);
  727.     }
  729.     /**
  730.      * {@inheritdoc}
  731.      */
  732.     public function getOwningTable($fieldName)
  733.     {
  734.         return $this->class->getTableName();
  735.     }
  737.     /**
  738.      * {@inheritdoc}
  739.      */
  740.     public function load(array $criteria, $entity = null, $assoc = null, array $hints = [], $lockMode = null, $limit = null, array $orderBy = null)
  741.     {
  742.         $this->switchPersisterContext(null, $limit);
  744.         $sql = $this->getSelectSQL($criteria, $assoc, $lockMode, $limit, null, $orderBy);
  745.         [$params, $types] = $this->expandParameters($criteria);
  746.         $stmt = $this->conn->executeQuery($sql, $params, $types);
  748.         if ($entity !== null) {
  749.             $hints[Query::HINT_REFRESH]         = true;
  750.             $hints[Query::HINT_REFRESH_ENTITY]  = $entity;
  751.         }
  753.         $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  754.         $entities = $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, $hints);
  756.         return $entities ? $entities[0] : null;
  757.     }
  759.     /**
  760.      * {@inheritdoc}
  761.      */
  762.     public function loadById(array $identifier, $entity = null)
  763.     {
  764.         return $this->load($identifier, $entity);
  765.     }
  767.     /**
  768.      * {@inheritdoc}
  769.      */
  770.     public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
  771.     {
  772.         if (($foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc['targetEntity'])) != false) {
  773.             return $foundEntity;
  774.         }
  776.         $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  778.         if ($assoc['isOwningSide']) {
  779.             $isInverseSingleValued = $assoc['inversedBy'] && ! $targetClass->isCollectionValuedAssociation($assoc['inversedBy']);
  781.             // Mark inverse side as fetched in the hints, otherwise the UoW would
  782.             // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
  783.             $hints = [];
  785.             if ($isInverseSingleValued) {
  786.                 $hints['fetched']["r"][$assoc['inversedBy']] = true;
  787.             }
  789.             /* cascade read-only status
  790.             if ($this->em->getUnitOfWork()->isReadOnly($sourceEntity)) {
  791.                 $hints[Query::HINT_READ_ONLY] = true;
  792.             }
  793.             */
  795.             $targetEntity = $this->load($identifier, null, $assoc, $hints);
  797.             // Complete bidirectional association, if necessary
  798.             if ($targetEntity !== null && $isInverseSingleValued) {
  799.                 $targetClass->reflFields[$assoc['inversedBy']]->setValue($targetEntity, $sourceEntity);
  800.             }
  802.             return $targetEntity;
  803.         }
  805.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  806.         $owningAssoc = $targetClass->getAssociationMapping($assoc['mappedBy']);
  808.         $computedIdentifier = [];
  810.         // TRICKY: since the association is specular source and target are flipped
  811.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  812.             if ( ! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
  813.                 throw MappingException::joinColumnMustPointToMappedField(
  814.                     $sourceClass->name, $sourceKeyColumn
  815.                 );
  816.             }
  818.             $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  819.                 $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
  820.         }
  822.         $targetEntity = $this->load($computedIdentifier, null, $assoc);
  824.         if ($targetEntity !== null) {
  825.             $targetClass->setFieldValue($targetEntity, $assoc['mappedBy'], $sourceEntity);
  826.         }
  828.         return $targetEntity;
  829.     }
  831.     /**
  832.      * {@inheritdoc}
  833.      */
  834.     public function refresh(array $id, $entity, $lockMode = null)
  835.     {
  836.         $sql = $this->getSelectSQL($id, null, $lockMode);
  837.         [$params, $types] = $this->expandParameters($id);
  838.         $stmt = $this->conn->executeQuery($sql, $params, $types);
  840.         $hydrator = $this->em->newHydrator(Query::HYDRATE_OBJECT);
  841.         $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
  842.     }
  844.     /**
  845.      * {@inheritDoc}
  846.      */
  847.     public function count($criteria = [])
  848.     {
  849.         $sql = $this->getCountSQL($criteria);
  851.         [$params, $types] = $criteria instanceof Criteria
  852.             ? $this->expandCriteriaParameters($criteria)
  853.             : $this->expandParameters($criteria);
  855.         return (int) $this->conn->executeQuery($sql, $params, $types)->fetchColumn();
  856.     }
  858.     /**
  859.      * {@inheritdoc}
  860.      */
  861.     public function loadCriteria(Criteria $criteria)
  862.     {
  863.         $orderBy = $criteria->getOrderings();
  864.         $limit   = $criteria->getMaxResults();
  865.         $offset  = $criteria->getFirstResult();
  866.         $query   = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  868.         [$params, $types] = $this->expandCriteriaParameters($criteria);
  870.         $stmt       = $this->conn->executeQuery($query, $params, $types);
  871.         $hydrator   = $this->em->newHydrator(($this->currentPersisterContext->selectJoinSql) ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  873.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]
  874.         );
  875.     }
  877.     /**
  878.      * {@inheritdoc}
  879.      */
  880.     public function expandCriteriaParameters(Criteria $criteria)
  881.     {
  882.         $expression = $criteria->getWhereExpression();
  883.         $sqlParams  = [];
  884.         $sqlTypes   = [];
  886.         if ($expression === null) {
  887.             return [$sqlParams, $sqlTypes];
  888.         }
  890.         $valueVisitor = new SqlValueVisitor();
  892.         $valueVisitor->dispatch($expression);
  894.         [$params, $types] = $valueVisitor->getParamsAndTypes();
  896.         foreach ($params as $param) {
  897.             $sqlParams = array_merge($sqlParams, $this->getValues($param));
  898.         }
  900.         foreach ($types as $type) {
  901.             [$field, $value] = $type;
  902.             $sqlTypes = array_merge($sqlTypes, $this->getTypes($field, $value, $this->class));
  903.         }
  905.         return [$sqlParams, $sqlTypes];
  906.     }
  908.     /**
  909.      * {@inheritdoc}
  910.      */
  911.     public function loadAll(array $criteria = [], array $orderBy = null, $limit = null, $offset = null)
  912.     {
  913.         $this->switchPersisterContext($offset, $limit);
  915.         $sql = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  916.         [$params, $types] = $this->expandParameters($criteria);
  917.         $stmt = $this->conn->executeQuery($sql, $params, $types);
  919.         $hydrator = $this->em->newHydrator(($this->currentPersisterContext->selectJoinSql) ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  921.         return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]
  922.         );
  923.     }
  925.     /**
  926.      * {@inheritdoc}
  927.      */
  928.     public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  929.     {
  930.         $this->switchPersisterContext($offset, $limit);
  932.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity, $offset, $limit);
  934.         return $this->loadArrayFromStatement($assoc, $stmt);
  935.     }
  937.     /**
  938.      * Loads an array of entities from a given DBAL statement.
  939.      *
  940.      * @param array                    $assoc
  941.      * @param \Doctrine\DBAL\Statement $stmt
  942.      *
  943.      * @return array
  944.      */
  945.     private function loadArrayFromStatement($assoc, $stmt)
  946.     {
  947.         $rsm    = $this->currentPersisterContext->rsm;
  948.         $hints  = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
  950.         if (isset($assoc['indexBy'])) {
  951.             $rsm = clone ($this->currentPersisterContext->rsm); // this is necessary because the "default rsm" should be changed.
  952.             $rsm->addIndexBy('r', $assoc['indexBy']);
  953.         }
  955.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  956.     }
  958.     /**
  959.      * Hydrates a collection from a given DBAL statement.
  960.      *
  961.      * @param array                    $assoc
  962.      * @param \Doctrine\DBAL\Statement $stmt
  963.      * @param PersistentCollection     $coll
  964.      *
  965.      * @return array
  966.      */
  967.     private function loadCollectionFromStatement($assoc, $stmt, $coll)
  968.     {
  969.         $rsm   = $this->currentPersisterContext->rsm;
  970.         $hints = [
  971.             UnitOfWork::HINT_DEFEREAGERLOAD => true,
  972.             'collection' => $coll
  973.         ];
  975.         if (isset($assoc['indexBy'])) {
  976.             $rsm = clone ($this->currentPersisterContext->rsm); // this is necessary because the "default rsm" should be changed.
  977.             $rsm->addIndexBy('r', $assoc['indexBy']);
  978.         }
  980.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  981.     }
  983.     /**
  984.      * {@inheritdoc}
  985.      */
  986.     public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  987.     {
  988.         $stmt = $this->getManyToManyStatement($assoc, $sourceEntity);
  990.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  991.     }
  993.     /**
  994.      * @param array    $assoc
  995.      * @param object   $sourceEntity
  996.      * @param int|null $offset
  997.      * @param int|null $limit
  998.      *
  999.      * @return \Doctrine\DBAL\Driver\Statement
  1000.      *
  1001.      * @throws \Doctrine\ORM\Mapping\MappingException
  1002.      */
  1003.     private function getManyToManyStatement(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1004.     {
  1005.         $this->switchPersisterContext($offset, $limit);
  1007.         $sourceClass    = $this->em->getClassMetadata($assoc['sourceEntity']);
  1008.         $class          = $sourceClass;
  1009.         $association    = $assoc;
  1010.         $criteria       = [];
  1011.         $parameters     = [];
  1013.         if ( ! $assoc['isOwningSide']) {
  1014.             $class       = $this->em->getClassMetadata($assoc['targetEntity']);
  1015.             $association = $class->associationMappings[$assoc['mappedBy']];
  1016.         }
  1018.         $joinColumns = $assoc['isOwningSide']
  1019.             ? $association['joinTable']['joinColumns']
  1020.             : $association['joinTable']['inverseJoinColumns'];
  1022.         $quotedJoinTable = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1024.         foreach ($joinColumns as $joinColumn) {
  1025.             $sourceKeyColumn    = $joinColumn['referencedColumnName'];
  1026.             $quotedKeyColumn    = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1028.             switch (true) {
  1029.                 case $sourceClass->containsForeignIdentifier:
  1030.                     $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1031.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1033.                     if (isset($sourceClass->associationMappings[$field])) {
  1034.                         $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1035.                         $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1036.                     }
  1038.                     break;
  1040.                 case isset($sourceClass->fieldNames[$sourceKeyColumn]):
  1041.                     $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1042.                     $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1044.                     break;
  1046.                 default:
  1047.                     throw MappingException::joinColumnMustPointToMappedField(
  1048.                         $sourceClass->name, $sourceKeyColumn
  1049.                     );
  1050.             }
  1052.             $criteria[$quotedJoinTable . '.' . $quotedKeyColumn] = $value;
  1053.             $parameters[] = [
  1054.                 'value' => $value,
  1055.                 'field' => $field,
  1056.                 'class' => $sourceClass,
  1057.             ];
  1058.         }
  1060.         $sql = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1061.         [$params, $types] = $this->expandToManyParameters($parameters);
  1063.         return $this->conn->executeQuery($sql, $params, $types);
  1064.     }
  1066.     /**
  1067.      * {@inheritdoc}
  1068.      */
  1069.     public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, array $orderBy = null)
  1070.     {
  1071.         $this->switchPersisterContext($offset, $limit);
  1073.         $lockSql    = '';
  1074.         $joinSql    = '';
  1075.         $orderBySql = '';
  1077.         if ($assoc != null && $assoc['type'] == ClassMetadata::MANY_TO_MANY) {
  1078.             $joinSql = $this->getSelectManyToManyJoinSQL($assoc);
  1079.         }
  1081.         if (isset($assoc['orderBy'])) {
  1082.             $orderBy = $assoc['orderBy'];
  1083.         }
  1085.         if ($orderBy) {
  1086.             $orderBySql = $this->getOrderBySQL($orderBy, $this->getSQLTableAlias($this->class->name));
  1087.         }
  1089.         $conditionSql = ($criteria instanceof Criteria)
  1090.             ? $this->getSelectConditionCriteriaSQL($criteria)
  1091.             : $this->getSelectConditionSQL($criteria, $assoc);
  1093.         switch ($lockMode) {
  1094.             case LockMode::PESSIMISTIC_READ:
  1095.                 $lockSql = ' ' . $this->platform->getReadLockSQL();
  1096.                 break;
  1098.             case LockMode::PESSIMISTIC_WRITE:
  1099.                 $lockSql = ' ' . $this->platform->getWriteLockSQL();
  1100.                 break;
  1101.         }
  1103.         $columnList = $this->getSelectColumnsSQL();
  1104.         $tableAlias = $this->getSQLTableAlias($this->class->name);
  1105.         $filterSql  = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1106.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1108.         if ('' !== $filterSql) {
  1109.             $conditionSql = $conditionSql
  1110.                 ? $conditionSql . ' AND ' . $filterSql
  1111.                 : $filterSql;
  1112.         }
  1114.         $select = 'SELECT ' . $columnList;
  1115.         $from   = ' FROM ' . $tableName . ' '. $tableAlias;
  1116.         $join   = $this->currentPersisterContext->selectJoinSql . $joinSql;
  1117.         $where  = ($conditionSql ? ' WHERE ' . $conditionSql : '');
  1118.         $lock   = $this->platform->appendLockHint($from, $lockMode);
  1119.         $query  = $select
  1120.             . $lock
  1121.             . $join
  1122.             . $where
  1123.             . $orderBySql;
  1125.         return $this->platform->modifyLimitQuery($query, $limit, $offset) . $lockSql;
  1126.     }
  1128.     /**
  1129.      * {@inheritDoc}
  1130.      */
  1131.     public function getCountSQL($criteria = [])
  1132.     {
  1133.         $tableName  = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1134.         $tableAlias = $this->getSQLTableAlias($this->class->name);
  1136.         $conditionSql = ($criteria instanceof Criteria)
  1137.             ? $this->getSelectConditionCriteriaSQL($criteria)
  1138.             : $this->getSelectConditionSQL($criteria);
  1140.         $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1142.         if ('' !== $filterSql) {
  1143.             $conditionSql = $conditionSql
  1144.                 ? $conditionSql . ' AND ' . $filterSql
  1145.                 : $filterSql;
  1146.         }
  1148.         $sql = 'SELECT COUNT(*) '
  1149.             . 'FROM ' . $tableName . ' ' . $tableAlias
  1150.             . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
  1152.         return $sql;
  1153.     }
  1155.     /**
  1156.      * Gets the ORDER BY SQL snippet for ordered collections.
  1157.      *
  1158.      * @param array  $orderBy
  1159.      * @param string $baseTableAlias
  1160.      *
  1161.      * @return string
  1162.      *
  1163.      * @throws \Doctrine\ORM\ORMException
  1164.      */
  1165.     final protected function getOrderBySQL(array $orderBy, $baseTableAlias) : string
  1166.     {
  1167.         $orderByList = [];
  1169.         foreach ($orderBy as $fieldName => $orientation) {
  1171.             $orientation = strtoupper(trim($orientation));
  1173.             if ($orientation != 'ASC' && $orientation != 'DESC') {
  1174.                 throw ORMException::invalidOrientation($this->class->name, $fieldName);
  1175.             }
  1177.             if (isset($this->class->fieldMappings[$fieldName])) {
  1178.                 $tableAlias = isset($this->class->fieldMappings[$fieldName]['inherited'])
  1179.                     ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
  1180.                     : $baseTableAlias;
  1182.                 $columnName    = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  1183.                 $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1185.                 continue;
  1186.             }
  1188.             if (isset($this->class->associationMappings[$fieldName])) {
  1190.                 if ( ! $this->class->associationMappings[$fieldName]['isOwningSide']) {
  1191.                     throw ORMException::invalidFindByInverseAssociation($this->class->name, $fieldName);
  1192.                 }
  1194.                 $tableAlias = isset($this->class->associationMappings[$fieldName]['inherited'])
  1195.                     ? $this->getSQLTableAlias($this->class->associationMappings[$fieldName]['inherited'])
  1196.                     : $baseTableAlias;
  1198.                 foreach ($this->class->associationMappings[$fieldName]['joinColumns'] as $joinColumn) {
  1199.                     $columnName    = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1200.                     $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1201.                 }
  1203.                 continue;
  1204.             }
  1206.             throw ORMException::unrecognizedField($fieldName);
  1207.         }
  1209.         return ' ORDER BY ' . implode(', ', $orderByList);
  1210.     }
  1212.     /**
  1213.      * Gets the SQL fragment with the list of columns to select when querying for
  1214.      * an entity in this persister.
  1215.      *
  1216.      * Subclasses should override this method to alter or change the select column
  1217.      * list SQL fragment. Note that in the implementation of BasicEntityPersister
  1218.      * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
  1219.      * Subclasses may or may not do the same.
  1220.      *
  1221.      * @return string The SQL fragment.
  1222.      */
  1223.     protected function getSelectColumnsSQL()
  1224.     {
  1225.         if ($this->currentPersisterContext->selectColumnListSql !== null) {
  1226.             return $this->currentPersisterContext->selectColumnListSql;
  1227.         }
  1229.         $columnList = [];
  1230.         $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r'); // r for root
  1232.         // Add regular columns to select list
  1233.         foreach ($this->class->fieldNames as $field) {
  1234.             $columnList[] = $this->getSelectColumnSQL($field, $this->class);
  1235.         }
  1237.         $this->currentPersisterContext->selectJoinSql    = '';
  1238.         $eagerAliasCounter      = 0;
  1240.         foreach ($this->class->associationMappings as $assocField => $assoc) {
  1241.             $assocColumnSQL = $this->getSelectColumnAssociationSQL($assocField, $assoc, $this->class);
  1243.             if ($assocColumnSQL) {
  1244.                 $columnList[] = $assocColumnSQL;
  1245.             }
  1247.             $isAssocToOneInverseSide = $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
  1248.             $isAssocFromOneEager     = $assoc['type'] !== ClassMetadata::MANY_TO_MANY && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
  1250.             if ( ! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
  1251.                 continue;
  1252.             }
  1254.             if ((($assoc['type'] & ClassMetadata::TO_MANY) > 0) && $this->currentPersisterContext->handlesLimits) {
  1255.                 continue;
  1256.             }
  1258.             $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1260.             if ($eagerEntity->inheritanceType != ClassMetadata::INHERITANCE_TYPE_NONE) {
  1261.                 continue; // now this is why you shouldn't use inheritance
  1262.             }
  1264.             $assocAlias = 'e' . ($eagerAliasCounter++);
  1265.             $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc['targetEntity'], $assocAlias, 'r', $assocField);
  1267.             foreach ($eagerEntity->fieldNames as $field) {
  1268.                 $columnList[] = $this->getSelectColumnSQL($field, $eagerEntity, $assocAlias);
  1269.             }
  1271.             foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
  1272.                 $eagerAssocColumnSQL = $this->getSelectColumnAssociationSQL(
  1273.                     $eagerAssocField, $eagerAssoc, $eagerEntity, $assocAlias
  1274.                 );
  1276.                 if ($eagerAssocColumnSQL) {
  1277.                     $columnList[] = $eagerAssocColumnSQL;
  1278.                 }
  1279.             }
  1281.             $association    = $assoc;
  1282.             $joinCondition  = [];
  1284.             if (isset($assoc['indexBy'])) {
  1285.                 $this->currentPersisterContext->rsm->addIndexBy($assocAlias, $assoc['indexBy']);
  1286.             }
  1288.             if ( ! $assoc['isOwningSide']) {
  1289.                 $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1290.                 $association = $eagerEntity->getAssociationMapping($assoc['mappedBy']);
  1291.             }
  1293.             $joinTableAlias = $this->getSQLTableAlias($eagerEntity->name, $assocAlias);
  1294.             $joinTableName  = $this->quoteStrategy->getTableName($eagerEntity, $this->platform);
  1296.             if ($assoc['isOwningSide']) {
  1297.                 $tableAlias           = $this->getSQLTableAlias($association['targetEntity'], $assocAlias);
  1298.                 $this->currentPersisterContext->selectJoinSql .= ' ' . $this->getJoinSQLForJoinColumns($association['joinColumns']);
  1300.                 foreach ($association['joinColumns'] as $joinColumn) {
  1301.                     $sourceCol       = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1302.                     $targetCol       = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1303.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'])
  1304.                                         . '.' . $sourceCol . ' = ' . $tableAlias . '.' . $targetCol;
  1305.                 }
  1307.                 // Add filter SQL
  1308.                 if ($filterSql = $this->generateFilterConditionSQL($eagerEntity, $tableAlias)) {
  1309.                     $joinCondition[] = $filterSql;
  1310.                 }
  1312.             } else {
  1314.                 $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
  1316.                 foreach ($association['joinColumns'] as $joinColumn) {
  1317.                     $sourceCol       = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1318.                     $targetCol       = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1320.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'], $assocAlias) . '.' . $sourceCol . ' = '
  1321.                         . $this->getSQLTableAlias($association['targetEntity']) . '.' . $targetCol;
  1322.                 }
  1323.             }
  1325.             $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';
  1326.             $this->currentPersisterContext->selectJoinSql .= implode(' AND ', $joinCondition);
  1327.         }
  1329.         $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
  1331.         return $this->currentPersisterContext->selectColumnListSql;
  1332.     }
  1334.     /**
  1335.      * Gets the SQL join fragment used when selecting entities from an association.
  1336.      *
  1337.      * @param string        $field
  1338.      * @param array         $assoc
  1339.      * @param ClassMetadata $class
  1340.      * @param string        $alias
  1341.      *
  1342.      * @return string
  1343.      */
  1344.     protected function getSelectColumnAssociationSQL($field, $assoc, ClassMetadata $class, $alias = 'r')
  1345.     {
  1346.         if ( ! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) ) {
  1347.             return '';
  1348.         }
  1350.         $columnList    = [];
  1351.         $targetClass   = $this->em->getClassMetadata($assoc['targetEntity']);
  1352.         $isIdentifier  = isset($assoc['id']) && $assoc['id'] === true;
  1353.         $sqlTableAlias = $this->getSQLTableAlias($class->name, ($alias == 'r' ? '' : $alias));
  1355.         foreach ($assoc['joinColumns'] as $joinColumn) {
  1356.             $quotedColumn     = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1357.             $resultColumnName = $this->getSQLColumnAlias($joinColumn['name']);
  1358.             $type             = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  1360.             $this->currentPersisterContext->rsm->addMetaResult($alias, $resultColumnName, $joinColumn['name'], $isIdentifier, $type);
  1362.             $columnList[] = sprintf('%s.%s AS %s', $sqlTableAlias, $quotedColumn, $resultColumnName);
  1363.         }
  1365.         return implode(', ', $columnList);
  1366.     }
  1368.     /**
  1369.      * Gets the SQL join fragment used when selecting entities from a
  1370.      * many-to-many association.
  1371.      *
  1372.      * @param array $manyToMany
  1373.      *
  1374.      * @return string
  1375.      */
  1376.     protected function getSelectManyToManyJoinSQL(array $manyToMany)
  1377.     {
  1378.         $conditions         = [];
  1379.         $association        = $manyToMany;
  1380.         $sourceTableAlias   = $this->getSQLTableAlias($this->class->name);
  1382.         if ( ! $manyToMany['isOwningSide']) {
  1383.             $targetEntity   = $this->em->getClassMetadata($manyToMany['targetEntity']);
  1384.             $association    = $targetEntity->associationMappings[$manyToMany['mappedBy']];
  1385.         }
  1387.         $joinTableName  = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  1388.         $joinColumns    = ($manyToMany['isOwningSide'])
  1389.             ? $association['joinTable']['inverseJoinColumns']
  1390.             : $association['joinTable']['joinColumns'];
  1392.         foreach ($joinColumns as $joinColumn) {
  1393.             $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1394.             $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1395.             $conditions[]       = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableName . '.' . $quotedSourceColumn;
  1396.         }
  1398.         return ' INNER JOIN ' . $joinTableName . ' ON ' . implode(' AND ', $conditions);
  1399.     }
  1401.     /**
  1402.      * {@inheritdoc}
  1403.      */
  1404.     public function getInsertSQL()
  1405.     {
  1406.         if ($this->insertSql !== null) {
  1407.             return $this->insertSql;
  1408.         }
  1410.         $columns   = $this->getInsertColumnList();
  1411.         $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1413.         if (empty($columns)) {
  1414.             $identityColumn  = $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class, $this->platform);
  1415.             $this->insertSql = $this->platform->getEmptyIdentityInsertSQL($tableName, $identityColumn);
  1417.             return $this->insertSql;
  1418.         }
  1420.         $values  = [];
  1421.         $columns = array_unique($columns);
  1423.         foreach ($columns as $column) {
  1424.             $placeholder = '?';
  1425. //MC 20210603 DEBUT  Ajouter pour resoudre le problème de champs inexistants dû au type JSONB explication dans le fichier Modifications apportées à Symfony.docx
  1426.             if (strpos($column, '->>')) {
  1427.                 continue;
  1428.             }
  1429. //MC 20210603 FIN
  1431.             if (isset($this->class->fieldNames[$column])
  1432.                 && isset($this->columnTypes[$this->class->fieldNames[$column]])
  1433.                 && isset($this->class->fieldMappings[$this->class->fieldNames[$column]]['requireSQLConversion'])) {
  1434.                 $type        = Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
  1435.                 $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  1436.             }
  1438.             $values[] = $placeholder;
  1439.         }
  1441.         $columns = implode(', ', $columns);
  1442.         $values  = implode(', ', $values);
  1444.         $this->insertSql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tableName, $columns, $values);
  1446.         return $this->insertSql;
  1447.     }
  1449.     /**
  1450.      * Gets the list of columns to put in the INSERT SQL statement.
  1451.      *
  1452.      * Subclasses should override this method to alter or change the list of
  1453.      * columns placed in the INSERT statements used by the persister.
  1454.      *
  1455.      * @return string[] The list of columns.
  1456.      *
  1457.      * @psalm-return list<string>
  1458.      */
  1459.     protected function getInsertColumnList()
  1460.     {
  1461.         $columns = [];
  1463.         foreach ($this->class->reflFields as $name => $field) {
  1464.             if ($this->class->isVersioned && $this->class->versionField == $name) {
  1465.                 continue;
  1466.             }
  1468.             if (isset($this->class->embeddedClasses[$name])) {
  1469.                 continue;
  1470.             }
  1472.             if (isset($this->class->associationMappings[$name])) {
  1473.                 $assoc = $this->class->associationMappings[$name];
  1475.                 if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  1476.                     foreach ($assoc['joinColumns'] as $joinColumn) {
  1477. //MC 20210603 DEBUT Ajouté pour resoudre le problème de champs inexistants dû au type JSONB explication dans le fichier Modifications apportées à Symfony.docx
  1478.                         if (strpos($joinColumn['name'], '->>')) {
  1479.                             continue;
  1480.                         }
  1481. //MC 20210603 FIN
  1482.                         $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1483.                     }
  1484.                 }
  1486.                 continue;
  1487.             }
  1489.             if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] != $name) {
  1490.                 $columns[]                = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
  1491.                 $this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
  1492.             }
  1493.         }
  1495.         return $columns;
  1496.     }
  1498.     /**
  1499.      * Gets the SQL snippet of a qualified column name for the given field name.
  1500.      *
  1501.      * @param string        $field The field name.
  1502.      * @param ClassMetadata $class The class that declares this field. The table this class is
  1503.      *                             mapped to must own the column for the given field.
  1504.      * @param string        $alias
  1505.      *
  1506.      * @return string
  1507.      */
  1508.     protected function getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r')
  1509.     {
  1510.         $root         = $alias == 'r' ? '' : $alias ;
  1511.         $tableAlias   = $this->getSQLTableAlias($class->name, $root);
  1512.         $fieldMapping = $class->fieldMappings[$field];
  1513.         $sql          = sprintf('%s.%s', $tableAlias, $this->quoteStrategy->getColumnName($field, $class, $this->platform));
  1514.         $columnAlias  = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1516.         $this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field);
  1518.         if (isset($fieldMapping['requireSQLConversion'])) {
  1519.             $type = Type::getType($fieldMapping['type']);
  1520.             $sql  = $type->convertToPHPValueSQL($sql, $this->platform);
  1521.         }
  1523.         return $sql . ' AS ' . $columnAlias;
  1524.     }
  1526.     /**
  1527.      * Gets the SQL table alias for the given class name.
  1528.      *
  1529.      * @param string $className
  1530.      * @param string $assocName
  1531.      *
  1532.      * @return string The SQL table alias.
  1533.      *
  1534.      * @todo Reconsider. Binding table aliases to class names is not such a good idea.
  1535.      */
  1536.     protected function getSQLTableAlias($className, $assocName = '')
  1537.     {
  1538.         if ($assocName) {
  1539.             $className .= '#' . $assocName;
  1540.         }
  1542.         if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
  1543.             return $this->currentPersisterContext->sqlTableAliases[$className];
  1544.         }
  1546.         $tableAlias = 't' . $this->currentPersisterContext->sqlAliasCounter++;
  1548.         $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
  1550.         return $tableAlias;
  1551.     }
  1553.     /**
  1554.      * {@inheritdoc}
  1555.      */
  1556.     public function lock(array $criteria, $lockMode)
  1557.     {
  1558.         $lockSql      = '';
  1559.         $conditionSql = $this->getSelectConditionSQL($criteria);
  1561.         switch ($lockMode) {
  1562.             case LockMode::PESSIMISTIC_READ:
  1563.                 $lockSql = $this->platform->getReadLockSQL();
  1565.                 break;
  1566.             case LockMode::PESSIMISTIC_WRITE:
  1568.                 $lockSql = $this->platform->getWriteLockSQL();
  1569.                 break;
  1570.         }
  1572.         $lock  = $this->getLockTablesSql($lockMode);
  1573.         $where = ($conditionSql ? ' WHERE ' . $conditionSql : '') . ' ';
  1574.         $sql = 'SELECT 1 '
  1575.              . $lock
  1576.              . $where
  1577.              . $lockSql;
  1579.         [$params, $types] = $this->expandParameters($criteria);
  1581.         $this->conn->executeQuery($sql, $params, $types);
  1582.     }
  1584.     /**
  1585.      * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
  1586.      *
  1587.      * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants.
  1588.      *
  1589.      * @return string
  1590.      */
  1591.     protected function getLockTablesSql($lockMode)
  1592.     {
  1593.         return $this->platform->appendLockHint(
  1594.             'FROM '
  1595.             . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
  1596.             . $this->getSQLTableAlias($this->class->name),
  1597.             $lockMode
  1598.         );
  1599.     }
  1601.     /**
  1602.      * Gets the Select Where Condition from a Criteria object.
  1603.      *
  1604.      * @param \Doctrine\Common\Collections\Criteria $criteria
  1605.      *
  1606.      * @return string
  1607.      */
  1608.     protected function getSelectConditionCriteriaSQL(Criteria $criteria)
  1609.     {
  1610.         $expression = $criteria->getWhereExpression();
  1612.         if ($expression === null) {
  1613.             return '';
  1614.         }
  1616.         $visitor = new SqlExpressionVisitor($this, $this->class);
  1618.         return $visitor->dispatch($expression);
  1619.     }
  1621.     /**
  1622.      * {@inheritdoc}
  1623.      */
  1624.     public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
  1625.     {
  1626.         $selectedColumns = [];
  1627.         $columns         = $this->getSelectConditionStatementColumnSQL($field, $assoc);
  1629.         if (count($columns) > 1 && $comparison === Comparison::IN) {
  1630.             /*
  1631.              *  @todo try to support multi-column IN expressions.
  1632.              *  Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
  1633.              */
  1634.             throw ORMException::cantUseInOperatorOnCompositeKeys();
  1635.         }
  1637.         foreach ($columns as $column) {
  1638.             $placeholder = '?';
  1640.             if (isset($this->class->fieldMappings[$field]['requireSQLConversion'])) {
  1641.                 $type        = Type::getType($this->class->fieldMappings[$field]['type']);
  1642.                 $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->platform);
  1643.             }
  1645.             if (null !== $comparison) {
  1646.                 // special case null value handling
  1647.                 if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && null ===$value) {
  1648.                     $selectedColumns[] = $column . ' IS NULL';
  1650.                     continue;
  1651.                 }
  1653.                 if ($comparison === Comparison::NEQ && null === $value) {
  1654.                     $selectedColumns[] = $column . ' IS NOT NULL';
  1656.                     continue;
  1657.                 }
  1659.                 $selectedColumns[] = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
  1661.                 continue;
  1662.             }
  1664.             if (is_array($value)) {
  1665.                 $in = sprintf('%s IN (%s)', $column, $placeholder);
  1667.                 if (false !== array_search(null, $value, true)) {
  1668.                     $selectedColumns[] = sprintf('(%s OR %s IS NULL)', $in, $column);
  1670.                     continue;
  1671.                 }
  1673.                 $selectedColumns[] = $in;
  1675.                 continue;
  1676.             }
  1678.             if (null === $value) {
  1679.                 $selectedColumns[] = sprintf('%s IS NULL', $column);
  1681.                 continue;
  1682.             }
  1684.             $selectedColumns[] = sprintf('%s = %s', $column, $placeholder);
  1685.         }
  1687.         return implode(' AND ', $selectedColumns);
  1688.     }
  1690.     /**
  1691.      * Builds the left-hand-side of a where condition statement.
  1692.      *
  1693.      * @param string     $field
  1694.      * @param array|null $assoc
  1695.      *
  1696.      * @return string[]
  1697.      *
  1698.      * @throws \Doctrine\ORM\ORMException
  1699.      *
  1700.      * @psalm-return list<string>
  1701.      */
  1702.     private function getSelectConditionStatementColumnSQL($field, $assoc = null)
  1703.     {
  1704.         if (isset($this->class->fieldMappings[$field])) {
  1705.             $className = $this->class->fieldMappings[$field]['inherited'] ?? $this->class->name;
  1707.             return [$this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getColumnName($field, $this->class, $this->platform)];
  1708.         }
  1710.         if (isset($this->class->associationMappings[$field])) {
  1711.             $association = $this->class->associationMappings[$field];
  1712.             // Many-To-Many requires join table check for joinColumn
  1713.             $columns = [];
  1714.             $class   = $this->class;
  1716.             if ($association['type'] === ClassMetadata::MANY_TO_MANY) {
  1717.                 if ( ! $association['isOwningSide']) {
  1718.                     $association = $assoc;
  1719.                 }
  1721.                 $joinTableName = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1722.                 $joinColumns   = $assoc['isOwningSide']
  1723.                     ? $association['joinTable']['joinColumns']
  1724.                     : $association['joinTable']['inverseJoinColumns'];
  1727.                 foreach ($joinColumns as $joinColumn) {
  1728.                     $columns[] = $joinTableName . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1729.                 }
  1731.             } else {
  1732.                 if ( ! $association['isOwningSide']) {
  1733.                     throw ORMException::invalidFindByInverseAssociation($this->class->name, $field);
  1734.                 }
  1736.                 $className  = (isset($association['inherited']))
  1737.                     ? $association['inherited']
  1738.                     : $this->class->name;
  1740.                 foreach ($association['joinColumns'] as $joinColumn) {
  1741.                     $columns[] = $this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1742.                 }
  1743.             }
  1744.             return $columns;
  1745.         }
  1747.         if ($assoc !== null && strpos($field, " ") === false && strpos($field, "(") === false) {
  1748.             // very careless developers could potentially open up this normally hidden api for userland attacks,
  1749.             // therefore checking for spaces and function calls which are not allowed.
  1751.             // found a join column condition, not really a "field"
  1752.             return [$field];
  1753.         }
  1755.         throw ORMException::unrecognizedField($field);
  1756.     }
  1758.     /**
  1759.      * Gets the conditional SQL fragment used in the WHERE clause when selecting
  1760.      * entities in this persister.
  1761.      *
  1762.      * Subclasses are supposed to override this method if they intend to change
  1763.      * or alter the criteria by which entities are selected.
  1764.      *
  1765.      * @param array      $criteria
  1766.      * @param array|null $assoc
  1767.      *
  1768.      * @return string
  1769.      */
  1770.     protected function getSelectConditionSQL(array $criteria, $assoc = null)
  1771.     {
  1772.         $conditions = [];
  1774.         foreach ($criteria as $field => $value) {
  1775.             $conditions[] = $this->getSelectConditionStatementSQL($field, $value, $assoc);
  1776.         }
  1778.         return implode(' AND ', $conditions);
  1779.     }
  1781.     /**
  1782.      * {@inheritdoc}
  1783.      */
  1784.     public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1785.     {
  1786.         $this->switchPersisterContext($offset, $limit);
  1788.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity, $offset, $limit);
  1790.         return $this->loadArrayFromStatement($assoc, $stmt);
  1791.     }
  1793.     /**
  1794.      * {@inheritdoc}
  1795.      */
  1796.     public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1797.     {
  1798.         $stmt = $this->getOneToManyStatement($assoc, $sourceEntity);
  1800.         return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1801.     }
  1803.     /**
  1804.      * Builds criteria and execute SQL statement to fetch the one to many entities from.
  1805.      *
  1806.      * @param array    $assoc
  1807.      * @param object   $sourceEntity
  1808.      * @param int|null $offset
  1809.      * @param int|null $limit
  1810.      *
  1811.      * @return \Doctrine\DBAL\Statement
  1812.      */
  1813.     private function getOneToManyStatement(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1814.     {
  1815.         $this->switchPersisterContext($offset, $limit);
  1817.         $criteria    = [];
  1818.         $parameters  = [];
  1819.         $owningAssoc = $this->class->associationMappings[$assoc['mappedBy']];
  1820.         $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1821.         $tableAlias  = $this->getSQLTableAlias($owningAssoc['inherited'] ?? $this->class->name);
  1823.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  1824.             if ($sourceClass->containsForeignIdentifier) {
  1825.                 $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1826.                 $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1828.                 if (isset($sourceClass->associationMappings[$field])) {
  1829.                     $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1830.                     $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1831.                 }
  1833.                 $criteria[$tableAlias . "." . $targetKeyColumn] = $value;
  1834.                 $parameters[]                                   = [
  1835.                     'value' => $value,
  1836.                     'field' => $field,
  1837.                     'class' => $sourceClass,
  1838.                 ];
  1840.                 continue;
  1841.             }
  1843.             $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1844.             $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1846.             $criteria[$tableAlias . "." . $targetKeyColumn] = $value;
  1847.             $parameters[] = [
  1848.                 'value' => $value,
  1849.                 'field' => $field,
  1850.                 'class' => $sourceClass,
  1851.             ];
  1853.         }
  1855.         $sql                  = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1856.         [$params, $types] = $this->expandToManyParameters($parameters);
  1858.         return $this->conn->executeQuery($sql, $params, $types);
  1859.     }
  1861.     /**
  1862.      * {@inheritdoc}
  1863.      */
  1864.     public function expandParameters($criteria)
  1865.     {
  1866.         $params = [];
  1867.         $types  = [];
  1869.         foreach ($criteria as $field => $value) {
  1870.             if ($value === null) {
  1871.                 continue; // skip null values.
  1872.             }
  1874.             $types  = array_merge($types, $this->getTypes($field, $value, $this->class));
  1875.             $params = array_merge($params, $this->getValues($value));
  1876.         }
  1878.         return [$params, $types];
  1879.     }
  1881.     /**
  1882.      * Expands the parameters from the given criteria and use the correct binding types if found,
  1883.      * specialized for OneToMany or ManyToMany associations.
  1884.      *
  1885.      * @param mixed[][] $criteria an array of arrays containing following:
  1886.      *                             - field to which each criterion will be bound
  1887.      *                             - value to be bound
  1888.      *                             - class to which the field belongs to
  1889.      *
  1890.      * @return mixed[][]
  1891.      *
  1892.      * @psalm-return array{0: array, 1: list<mixed>}
  1893.      */
  1894.     private function expandToManyParameters($criteria)
  1895.     {
  1896.         $params = [];
  1897.         $types  = [];
  1899.         foreach ($criteria as $criterion) {
  1900.             if ($criterion['value'] === null) {
  1901.                 continue; // skip null values.
  1902.             }
  1904.             $types  = array_merge($types, $this->getTypes($criterion['field'], $criterion['value'], $criterion['class']));
  1905.             $params = array_merge($params, $this->getValues($criterion['value']));
  1906.         }
  1908.         return [$params, $types];
  1909.     }
  1911.     /**
  1912.      * Infers field types to be used by parameter type casting.
  1913.      *
  1914.      * @param string        $field
  1915.      * @param mixed         $value
  1916.      * @param ClassMetadata $class
  1917.      *
  1918.      * @return int[]|null[]|string[]
  1919.      *
  1920.      * @throws \Doctrine\ORM\Query\QueryException
  1921.      *
  1922.      * @psalm-return list<int|null|string>
  1923.      */
  1924.     private function getTypes($field, $value, ClassMetadata $class)
  1925.     {
  1926.         $types = [];
  1928.         switch (true) {
  1929.             case (isset($class->fieldMappings[$field])):
  1930.                 $types = array_merge($types, [$class->fieldMappings[$field]['type']]);
  1931.                 break;
  1933.             case (isset($class->associationMappings[$field])):
  1934.                 $assoc = $class->associationMappings[$field];
  1935.                 $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1937.                 if (! $assoc['isOwningSide']) {
  1938.                     $assoc = $class->associationMappings[$assoc['mappedBy']];
  1939.                     $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1940.                 }
  1942.                 $columns = $assoc['type'] === ClassMetadata::MANY_TO_MANY
  1943.                     ? $assoc['relationToTargetKeyColumns']
  1944.                     : $assoc['sourceToTargetKeyColumns'];
  1946.                 foreach ($columns as $column){
  1947.                     $types[] = PersisterHelper::getTypeOfColumn($column, $class, $this->em);
  1948.                 }
  1949.                 break;
  1951.             default:
  1952.                 $types[] = null;
  1953.                 break;
  1954.         }
  1956.         if (is_array($value)) {
  1957.             return array_map(function ($type) {
  1958.                 $type = Type::getType($type);
  1960.                 return $type->getBindingType() + Connection::ARRAY_PARAM_OFFSET;
  1961.             }, $types);
  1962.         }
  1964.         return $types;
  1965.     }
  1967.     /**
  1968.      * Retrieves the parameters that identifies a value.
  1969.      *
  1970.      * @param mixed $value
  1971.      *
  1972.      * @return array
  1973.      */
  1974.     private function getValues($value)
  1975.     {
  1976.         if (is_array($value)) {
  1977.             $newValue = [];
  1979.             foreach ($value as $itemValue) {
  1980.                 $newValue = array_merge($newValue, $this->getValues($itemValue));
  1981.             }
  1983.             return [$newValue];
  1984.         }
  1986.         if (is_object($value) && $this->em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($value))) {
  1987.             $class = $this->em->getClassMetadata(get_class($value));
  1988.             if ($class->isIdentifierComposite) {
  1989.                 $newValue = [];
  1991.                 foreach ($class->getIdentifierValues($value) as $innerValue) {
  1992.                     $newValue = array_merge($newValue, $this->getValues($innerValue));
  1993.                 }
  1995.                 return $newValue;
  1996.             }
  1997.         }
  1999.         return [$this->getIndividualValue($value)];
  2000.     }
  2002.     /**
  2003.      * Retrieves an individual parameter value.
  2004.      *
  2005.      * @param mixed $value
  2006.      *
  2007.      * @return mixed
  2008.      */
  2009.     private function getIndividualValue($value)
  2010.     {
  2011.         if ( ! is_object($value) || ! $this->em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($value))) {
  2012.             return $value;
  2013.         }
  2015.         return $this->em->getUnitOfWork()->getSingleIdentifierValue($value);
  2016.     }
  2018.     /**
  2019.      * {@inheritdoc}
  2020.      */
  2021.     public function exists($entity, Criteria $extraConditions = null)
  2022.     {
  2023.         $criteria = $this->class->getIdentifierValues($entity);
  2025.         if ( ! $criteria) {
  2026.             return false;
  2027.         }
  2029.         $alias = $this->getSQLTableAlias($this->class->name);
  2031.         $sql = 'SELECT 1 '
  2032.              . $this->getLockTablesSql(null)
  2033.              . ' WHERE ' . $this->getSelectConditionSQL($criteria);
  2035.         [$params, $types] = $this->expandParameters($criteria);
  2037.         if (null !== $extraConditions) {
  2038.             $sql                                 .= ' AND ' . $this->getSelectConditionCriteriaSQL($extraConditions);
  2039.             [$criteriaParams, $criteriaTypes] = $this->expandCriteriaParameters($extraConditions);
  2041.             $params = array_merge($params, $criteriaParams);
  2042.             $types  = array_merge($types, $criteriaTypes);
  2043.         }
  2045.         if ($filterSql = $this->generateFilterConditionSQL($this->class, $alias)) {
  2046.             $sql .= ' AND ' . $filterSql;
  2047.         }
  2049.         return (bool) $this->conn->fetchColumn($sql, $params, 0, $types);
  2050.     }
  2052.     /**
  2053.      * Generates the appropriate join SQL for the given join column.
  2054.      *
  2055.      * @param array $joinColumns The join columns definition of an association.
  2056.      *
  2057.      * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
  2058.      */
  2059.     protected function getJoinSQLForJoinColumns($joinColumns)
  2060.     {
  2061.         // if one of the join columns is nullable, return left join
  2062.         foreach ($joinColumns as $joinColumn) {
  2063.              if ( ! isset($joinColumn['nullable']) || $joinColumn['nullable']) {
  2064.                  return 'LEFT JOIN';
  2065.              }
  2066.         }
  2068.         return 'INNER JOIN';
  2069.     }
  2071.     /**
  2072.      * @param string $columnName
  2073.      *
  2074.      * @return string
  2075.      */
  2076.     public function getSQLColumnAlias($columnName)
  2077.     {
  2078.         return $this->quoteStrategy->getColumnAlias($columnName, $this->currentPersisterContext->sqlAliasCounter++, $this->platform);
  2079.     }
  2081.     /**
  2082.      * Generates the filter SQL for a given entity and table alias.
  2083.      *
  2084.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  2085.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  2086.      *
  2087.      * @return string The SQL query part to add to a query.
  2088.      */
  2089.     protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
  2090.     {
  2091.         $filterClauses = [];
  2093.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  2094.             if ('' !== $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias)) {
  2095.                 $filterClauses[] = '(' . $filterExpr . ')';
  2096.             }
  2097.         }
  2099.         $sql = implode(' AND ', $filterClauses);
  2101.         return $sql ? "(" . $sql . ")" : ""; // Wrap again to avoid "X or Y and FilterConditionSQL"
  2102.     }
  2104.     /**
  2105.      * Switches persister context according to current query offset/limits
  2106.      *
  2107.      * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
  2108.      *
  2109.      * @param null|int $offset
  2110.      * @param null|int $limit
  2111.      */
  2112.     protected function switchPersisterContext($offset, $limit)
  2113.     {
  2114.         if (null === $offset && null === $limit) {
  2115.             $this->currentPersisterContext = $this->noLimitsContext;
  2117.             return;
  2118.         }
  2120.         $this->currentPersisterContext = $this->limitsHandlingContext;
  2121.     }
  2123.     /**
  2124.      * @return string[]
  2125.      */
  2126.     protected function getClassIdentifiersTypes(ClassMetadata $class) : array
  2127.     {
  2128.         $entityManager = $this->em;
  2130.         return array_map(
  2131.             static function ($fieldName) use ($class, $entityManager) : string {
  2132.                 $types = PersisterHelper::getTypeOfField($fieldName, $class, $entityManager);
  2133.                 assert(isset($types[0]));
  2135.                 return $types[0];
  2136.             },
  2137.             $class->identifier
  2138.         );
  2139.     }
  2140. }