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

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.  */
  19. namespace Doctrine\ORM\Persisters\Entity;
  20. use Doctrine\Common\Collections\Criteria;
  21. use Doctrine\Common\Collections\Expr\Comparison;
  22. use Doctrine\Common\Util\ClassUtils;
  23. use Doctrine\DBAL\Connection;
  24. use Doctrine\DBAL\LockMode;
  25. use Doctrine\DBAL\Types\Type;
  26. use Doctrine\ORM\EntityManagerInterface;
  27. use Doctrine\ORM\Mapping\ClassMetadata;
  28. use Doctrine\ORM\Mapping\MappingException;
  29. use Doctrine\ORM\OptimisticLockException;
  30. use Doctrine\ORM\ORMException;
  31. use Doctrine\ORM\PersistentCollection;
  32. use Doctrine\ORM\Persisters\SqlExpressionVisitor;
  33. use Doctrine\ORM\Persisters\SqlValueVisitor;
  34. use Doctrine\ORM\Query;
  35. use Doctrine\ORM\UnitOfWork;
  36. use Doctrine\ORM\Utility\IdentifierFlattener;
  37. use Doctrine\ORM\Utility\PersisterHelper;
  38. use function array_map;
  39. use function array_merge;
  40. use function assert;
  41. use function reset;
  42. /**
  43.  * A BasicEntityPersister maps an entity to a single table in a relational database.
  44.  *
  45.  * A persister is always responsible for a single entity type.
  46.  *
  47.  * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
  48.  * state of entities onto a relational database when the UnitOfWork is committed,
  49.  * as well as for basic querying of entities and their associations (not DQL).
  50.  *
  51.  * The persisting operations that are invoked during a commit of a UnitOfWork to
  52.  * persist the persistent entity state are:
  53.  *
  54.  *   - {@link addInsert} : To schedule an entity for insertion.
  55.  *   - {@link executeInserts} : To execute all scheduled insertions.
  56.  *   - {@link update} : To update the persistent state of an entity.
  57.  *   - {@link delete} : To delete the persistent state of an entity.
  58.  *
  59.  * As can be seen from the above list, insertions are batched and executed all at once
  60.  * for increased efficiency.
  61.  *
  62.  * The querying operations invoked during a UnitOfWork, either through direct find
  63.  * requests or lazy-loading, are the following:
  64.  *
  65.  *   - {@link load} : Loads (the state of) a single, managed entity.
  66.  *   - {@link loadAll} : Loads multiple, managed entities.
  67.  *   - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
  68.  *   - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
  69.  *   - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
  70.  *
  71.  * The BasicEntityPersister implementation provides the default behavior for
  72.  * persisting and querying entities that are mapped to a single database table.
  73.  *
  74.  * Subclasses can be created to provide custom persisting and querying strategies,
  75.  * i.e. spanning multiple tables.
  76.  *
  77.  * @author Roman Borschel <roman@code-factory.org>
  78.  * @author Giorgio Sironi <piccoloprincipeazzurro@gmail.com>
  79.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  80.  * @author Alexander <iam.asm89@gmail.com>
  81.  * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
  82.  * @author Rob Caiger <rob@clocal.co.uk>
  83.  * @since 2.0
  84.  */
  85. class BasicEntityPersister implements EntityPersister
  86. {
  87.     /**
  88.      * @var array
  89.      */
  90.     static private $comparisonMap = [
  91.         Comparison::EQ          => '= %s',
  92.         Comparison::NEQ         => '!= %s',
  93.         Comparison::GT          => '> %s',
  94.         Comparison::GTE         => '>= %s',
  95.         Comparison::LT          => '< %s',
  96.         Comparison::LTE         => '<= %s',
  97.         Comparison::IN          => 'IN (%s)',
  98.         Comparison::NIN         => 'NOT IN (%s)',
  99.         Comparison::CONTAINS    => 'LIKE %s',
  100.         Comparison::STARTS_WITH => 'LIKE %s',
  101.         Comparison::ENDS_WITH   => 'LIKE %s',
  102.     ];
  103.     /**
  104.      * Metadata object that describes the mapping of the mapped entity class.
  105.      *
  106.      * @var \Doctrine\ORM\Mapping\ClassMetadata
  107.      */
  108.     protected $class;
  109.     /**
  110.      * The underlying DBAL Connection of the used EntityManager.
  111.      *
  112.      * @var \Doctrine\DBAL\Connection $conn
  113.      */
  114.     protected $conn;
  115.     /**
  116.      * The database platform.
  117.      *
  118.      * @var \Doctrine\DBAL\Platforms\AbstractPlatform
  119.      */
  120.     protected $platform;
  121.     /**
  122.      * The EntityManager instance.
  123.      *
  124.      * @var EntityManagerInterface
  125.      */
  126.     protected $em;
  127.     /**
  128.      * Queued inserts.
  129.      *
  130.      * @var array
  131.      */
  132.     protected $queuedInserts = [];
  133.     /**
  134.      * The map of column names to DBAL mapping types of all prepared columns used
  135.      * when INSERTing or UPDATEing an entity.
  136.      *
  137.      * @var array
  138.      *
  139.      * @see prepareInsertData($entity)
  140.      * @see prepareUpdateData($entity)
  141.      */
  142.     protected $columnTypes = [];
  143.     /**
  144.      * The map of quoted column names.
  145.      *
  146.      * @var array
  147.      *
  148.      * @see prepareInsertData($entity)
  149.      * @see prepareUpdateData($entity)
  150.      */
  151.     protected $quotedColumns = [];
  152.     /**
  153.      * The INSERT SQL statement used for entities handled by this persister.
  154.      * This SQL is only generated once per request, if at all.
  155.      *
  156.      * @var string
  157.      */
  158.     private $insertSql;
  159.     /**
  160.      * The quote strategy.
  161.      *
  162.      * @var \Doctrine\ORM\Mapping\QuoteStrategy
  163.      */
  164.     protected $quoteStrategy;
  165.     /**
  166.      * The IdentifierFlattener used for manipulating identifiers
  167.      *
  168.      * @var \Doctrine\ORM\Utility\IdentifierFlattener
  169.      */
  170.     private $identifierFlattener;
  171.     /**
  172.      * @var CachedPersisterContext
  173.      */
  174.     protected $currentPersisterContext;
  175.     /**
  176.      * @var CachedPersisterContext
  177.      */
  178.     private $limitsHandlingContext;
  179.     /**
  180.      * @var CachedPersisterContext
  181.      */
  182.     private $noLimitsContext;
  183.     /**
  184.      * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
  185.      * and persists instances of the class described by the given ClassMetadata descriptor.
  186.      *
  187.      * @param EntityManagerInterface $em
  188.      * @param ClassMetadata          $class
  189.      */
  190.     public function __construct(EntityManagerInterface $emClassMetadata $class)
  191.     {
  192.         $this->em                    $em;
  193.         $this->class                 $class;
  194.         $this->conn                  $em->getConnection();
  195.         $this->platform              $this->conn->getDatabasePlatform();
  196.         $this->quoteStrategy         $em->getConfiguration()->getQuoteStrategy();
  197.         $this->identifierFlattener   = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
  198.         $this->noLimitsContext       $this->currentPersisterContext = new CachedPersisterContext(
  199.             $class,
  200.             new Query\ResultSetMapping(),
  201.             false
  202.         );
  203.         $this->limitsHandlingContext = new CachedPersisterContext(
  204.             $class,
  205.             new Query\ResultSetMapping(),
  206.             true
  207.         );
  208.     }
  209.     /**
  210.      * {@inheritdoc}
  211.      */
  212.     public function getClassMetadata()
  213.     {
  214.         return $this->class;
  215.     }
  216.     /**
  217.      * {@inheritdoc}
  218.      */
  219.     public function getResultSetMapping()
  220.     {
  221.         return $this->currentPersisterContext->rsm;
  222.     }
  223.     /**
  224.      * {@inheritdoc}
  225.      */
  226.     public function addInsert($entity)
  227.     {
  228.         $this->queuedInserts[spl_object_hash($entity)] = $entity;
  229.     }
  230.     /**
  231.      * {@inheritdoc}
  232.      */
  233.     public function getInserts()
  234.     {
  235.         return $this->queuedInserts;
  236.     }
  237.     /**
  238.      * {@inheritdoc}
  239.      */
  240.     public function executeInserts()
  241.     {
  242.         if ( ! $this->queuedInserts) {
  243.             return [];
  244.         }
  245.         $postInsertIds  = [];
  246.         $idGenerator    $this->class->idGenerator;
  247.         $isPostInsertId $idGenerator->isPostInsertGenerator();
  248.         $stmt       $this->conn->prepare($this->getInsertSQL());
  249.         $tableName  $this->class->getTableName();
  250.         foreach ($this->queuedInserts as $entity) {
  251.             $insertData $this->prepareInsertData($entity);
  252.             if (isset($insertData[$tableName])) {
  253.                 $paramIndex 1;
  254.                 foreach ($insertData[$tableName] as $column => $value) {
  255.                     $stmt->bindValue($paramIndex++, $value$this->columnTypes[$column]);
  256.                 }
  257.             }
  258.             $stmt->execute();
  259.             if ($isPostInsertId) {
  260.                 $generatedId $idGenerator->generate($this->em$entity);
  261.                 $id = [
  262.                     $this->class->identifier[0] => $generatedId
  263.                 ];
  264.                 $postInsertIds[] = [
  265.                     'generatedId' => $generatedId,
  266.                     'entity' => $entity,
  267.                 ];
  268.             } else {
  269.                 $id $this->class->getIdentifierValues($entity);
  270.             }
  271.             if ($this->class->isVersioned) {
  272.                 $this->assignDefaultVersionValue($entity$id);
  273.             }
  274.         }
  275.         $stmt->closeCursor();
  276.         $this->queuedInserts = [];
  277.         return $postInsertIds;
  278.     }
  279.     /**
  280.      * Retrieves the default version value which was created
  281.      * by the preceding INSERT statement and assigns it back in to the
  282.      * entities version field.
  283.      *
  284.      * @param object $entity
  285.      * @param array  $id
  286.      *
  287.      * @return void
  288.      */
  289.     protected function assignDefaultVersionValue($entity, array $id)
  290.     {
  291.         $value $this->fetchVersionValue($this->class$id);
  292.         $this->class->setFieldValue($entity$this->class->versionField$value);
  293.     }
  294.     /**
  295.      * Fetches the current version value of a versioned entity.
  296.      *
  297.      * @param \Doctrine\ORM\Mapping\ClassMetadata $versionedClass
  298.      * @param array                               $id
  299.      *
  300.      * @return mixed
  301.      */
  302.     protected function fetchVersionValue($versionedClass, array $id)
  303.     {
  304.         $versionField $versionedClass->versionField;
  305.         $fieldMapping $versionedClass->fieldMappings[$versionField];
  306.         $tableName    $this->quoteStrategy->getTableName($versionedClass$this->platform);
  307.         $identifier   $this->quoteStrategy->getIdentifierColumnNames($versionedClass$this->platform);
  308.         $columnName   $this->quoteStrategy->getColumnName($versionField$versionedClass$this->platform);
  309.         // FIXME: Order with composite keys might not be correct
  310.         $sql 'SELECT ' $columnName
  311.              ' FROM '  $tableName
  312.              ' WHERE ' implode(' = ? AND '$identifier) . ' = ?';
  313.         $flatId $this->identifierFlattener->flattenIdentifier($versionedClass$id);
  314.         $value $this->conn->fetchColumn(
  315.             $sql,
  316.             array_values($flatId),
  317.             0,
  318.             $this->extractIdentifierTypes($id$versionedClass)
  319.         );
  320.         return Type::getType($fieldMapping['type'])->convertToPHPValue($value$this->platform);
  321.     }
  322.     /**
  323.      * @return int[]|null[]|string[]
  324.      *
  325.      * @psalm-return list<int|null|string>
  326.      */
  327.     private function extractIdentifierTypes(array $idClassMetadata $versionedClass) : array
  328.     {
  329.         $types = [];
  330.         foreach ($id as $field => $value) {
  331.             $types array_merge($types$this->getTypes($field$value$versionedClass));
  332.         }
  333.         return $types;
  334.     }
  335.     /**
  336.      * {@inheritdoc}
  337.      */
  338.     public function update($entity)
  339.     {
  340.         $tableName  $this->class->getTableName();
  341.         $updateData $this->prepareUpdateData($entity);
  342.         if ( ! isset($updateData[$tableName]) || ! ($data $updateData[$tableName])) {
  343.             return;
  344.         }
  345.         $isVersioned     $this->class->isVersioned;
  346.         $quotedTableName $this->quoteStrategy->getTableName($this->class$this->platform);
  347.         $this->updateTable($entity$quotedTableName$data$isVersioned);
  348.         if ($isVersioned) {
  349.             $id $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  350.             $this->assignDefaultVersionValue($entity$id);
  351.         }
  352.     }
  353.     /**
  354.      * Performs an UPDATE statement for an entity on a specific table.
  355.      * The UPDATE can optionally be versioned, which requires the entity to have a version field.
  356.      *
  357.      * @param object  $entity          The entity object being updated.
  358.      * @param string  $quotedTableName The quoted name of the table to apply the UPDATE on.
  359.      * @param array   $updateData      The map of columns to update (column => value).
  360.      * @param boolean $versioned       Whether the UPDATE should be versioned.
  361.      *
  362.      * @return void
  363.      *
  364.      * @throws \Doctrine\ORM\ORMException
  365.      * @throws \Doctrine\ORM\OptimisticLockException
  366.      */
  367.     protected final function updateTable($entity$quotedTableName, array $updateData$versioned false)
  368.     {
  369.         $set    = [];
  370.         $types  = [];
  371.         $params = [];
  372.         foreach ($updateData as $columnName => $value) {
  373.             $placeholder '?';
  374.             $column      $columnName;
  375.             switch (true) {
  376.                 case isset($this->class->fieldNames[$columnName]):
  377.                     $fieldName  $this->class->fieldNames[$columnName];
  378.                     $column     $this->quoteStrategy->getColumnName($fieldName$this->class$this->platform);
  379.                     if (isset($this->class->fieldMappings[$fieldName]['requireSQLConversion'])) {
  380.                         $type        Type::getType($this->columnTypes[$columnName]);
  381.                         $placeholder $type->convertToDatabaseValueSQL('?'$this->platform);
  382.                     }
  383.                     break;
  384.                 case isset($this->quotedColumns[$columnName]):
  385.                     $column $this->quotedColumns[$columnName];
  386.                     break;
  387.             }
  388.             $params[]   = $value;
  389.             $set[]      = $column ' = ' $placeholder;
  390.             $types[]    = $this->columnTypes[$columnName];
  391.         }
  392.         $where      = [];
  393.         $identifier $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  394.         foreach ($this->class->identifier as $idField) {
  395.             if ( ! isset($this->class->associationMappings[$idField])) {
  396.                 $params[] = $identifier[$idField];
  397.                 $types[]  = $this->class->fieldMappings[$idField]['type'];
  398.                 $where[]  = $this->quoteStrategy->getColumnName($idField$this->class$this->platform);
  399.                 continue;
  400.             }
  401.             $params[] = $identifier[$idField];
  402.             $where[]  = $this->quoteStrategy->getJoinColumnName(
  403.                 $this->class->associationMappings[$idField]['joinColumns'][0],
  404.                 $this->class,
  405.                 $this->platform
  406.             );
  407.             $targetMapping $this->em->getClassMetadata($this->class->associationMappings[$idField]['targetEntity']);
  408.             $targetType    PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping$this->em);
  409.             if ($targetType === []) {
  410.                 throw ORMException::unrecognizedField($targetMapping->identifier[0]);
  411.             }
  412.             $types[] = reset($targetType);
  413.         }
  414.         if ($versioned) {
  415.             $versionField       $this->class->versionField;
  416.             $versionFieldType   $this->class->fieldMappings[$versionField]['type'];
  417.             $versionColumn      $this->quoteStrategy->getColumnName($versionField$this->class$this->platform);
  418.             $where[]    = $versionColumn;
  419.             $types[]    = $this->class->fieldMappings[$versionField]['type'];
  420.             $params[]   = $this->class->reflFields[$versionField]->getValue($entity);
  421.             switch ($versionFieldType) {
  422.                 case Type::SMALLINT:
  423.                 case Type::INTEGER:
  424.                 case Type::BIGINT:
  425.                     $set[] = $versionColumn ' = ' $versionColumn ' + 1';
  426.                     break;
  427.                 case Type::DATETIME:
  428.                     $set[] = $versionColumn ' = CURRENT_TIMESTAMP';
  429.                     break;
  430.             }
  431.         }
  432.         $sql 'UPDATE ' $quotedTableName
  433.              ' SET ' implode(', '$set)
  434.              . ' WHERE ' implode(' = ? AND '$where) . ' = ?';
  435.         $result $this->conn->executeUpdate($sql$params$types);
  436.         if ($versioned && ! $result) {
  437.             throw OptimisticLockException::lockFailed($entity);
  438.         }
  439.     }
  440.     /**
  441.      * @todo Add check for platform if it supports foreign keys/cascading.
  442.      *
  443.      * @param array $identifier
  444.      *
  445.      * @return void
  446.      */
  447.     protected function deleteJoinTableRecords($identifier)
  448.     {
  449.         foreach ($this->class->associationMappings as $mapping) {
  450.             if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY) {
  451.                 continue;
  452.             }
  453.             // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
  454.             // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
  455.             $selfReferential = ($mapping['targetEntity'] == $mapping['sourceEntity']);
  456.             $class           $this->class;
  457.             $association     $mapping;
  458.             $otherColumns    = [];
  459.             $otherKeys       = [];
  460.             $keys            = [];
  461.             if ( ! $mapping['isOwningSide']) {
  462.                 $class       $this->em->getClassMetadata($mapping['targetEntity']);
  463.                 $association $class->associationMappings[$mapping['mappedBy']];
  464.             }
  465.             $joinColumns $mapping['isOwningSide']
  466.                 ? $association['joinTable']['joinColumns']
  467.                 : $association['joinTable']['inverseJoinColumns'];
  468.             if ($selfReferential) {
  469.                 $otherColumns = (! $mapping['isOwningSide'])
  470.                     ? $association['joinTable']['joinColumns']
  471.                     : $association['joinTable']['inverseJoinColumns'];
  472.             }
  473.             foreach ($joinColumns as $joinColumn) {
  474.                 $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn$class$this->platform);
  475.             }
  476.             foreach ($otherColumns as $joinColumn) {
  477.                 $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn$class$this->platform);
  478.             }
  479.             if (isset($mapping['isOnDeleteCascade'])) {
  480.                 continue;
  481.             }
  482.             $joinTableName $this->quoteStrategy->getJoinTableName($association$this->class$this->platform);
  483.             $this->conn->delete($joinTableNamearray_combine($keys$identifier));
  484.             if ($selfReferential) {
  485.                 $this->conn->delete($joinTableNamearray_combine($otherKeys$identifier));
  486.             }
  487.         }
  488.     }
  489.     /**
  490.      * {@inheritdoc}
  491.      */
  492.     public function delete($entity)
  493.     {
  494.         $class      $this->class;
  495.         $identifier $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  496.         $tableName  $this->quoteStrategy->getTableName($class$this->platform);
  497.         $idColumns  $this->quoteStrategy->getIdentifierColumnNames($class$this->platform);
  498.         $id         array_combine($idColumns$identifier);
  499.         $types      $this->getClassIdentifiersTypes($class);
  500.         $this->deleteJoinTableRecords($identifier);
  501.         return (bool) $this->conn->delete($tableName$id$types);
  502.     }
  503.     /**
  504.      * Prepares the changeset of an entity for database insertion (UPDATE).
  505.      *
  506.      * The changeset is obtained from the currently running UnitOfWork.
  507.      *
  508.      * During this preparation the array that is passed as the second parameter is filled with
  509.      * <columnName> => <value> pairs, grouped by table name.
  510.      *
  511.      * Example:
  512.      * <code>
  513.      * array(
  514.      *    'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
  515.      *    'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
  516.      *    ...
  517.      * )
  518.      * </code>
  519.      *
  520.      * @param object $entity The entity for which to prepare the data.
  521.      *
  522.      * @return mixed[][] The prepared data.
  523.      *
  524.      * @psalm-return array<string, array<array-key, mixed|null>>
  525.      */
  526.     protected function prepareUpdateData($entity)
  527.     {
  528.         $versionField null;
  529.         $result       = [];
  530.         $uow          $this->em->getUnitOfWork();
  531.         if (($versioned $this->class->isVersioned) != false) {
  532.             $versionField $this->class->versionField;
  533.         }
  534.         foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
  535.             if (isset($versionField) && $versionField == $field) {
  536.                 continue;
  537.             }
  538.             if (isset($this->class->embeddedClasses[$field])) {
  539.                 continue;
  540.             }
  541.             $newVal $change[1];
  542.             if ( ! isset($this->class->associationMappings[$field])) {
  543.                 $fieldMapping $this->class->fieldMappings[$field];
  544.                 $columnName   $fieldMapping['columnName'];
  545.                 $this->columnTypes[$columnName] = $fieldMapping['type'];
  546.                 $result[$this->getOwningTable($field)][$columnName] = $newVal;
  547.                 continue;
  548.             }
  549.             $assoc $this->class->associationMappings[$field];
  550.             // Only owning side of x-1 associations can have a FK column.
  551.             if ( ! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
  552.                 continue;
  553.             }
  554.             if ($newVal !== null) {
  555.                 $oid spl_object_hash($newVal);
  556.                 if (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal)) {
  557.                     // The associated entity $newVal is not yet persisted, so we must
  558.                     // set $newVal = null, in order to insert a null value and schedule an
  559.                     // extra update on the UnitOfWork.
  560.                     $uow->scheduleExtraUpdate($entity, [$field => [null$newVal]]);
  561.                     $newVal null;
  562.                 }
  563.             }
  564.             $newValId null;
  565.             if ($newVal !== null) {
  566.                 $newValId $uow->getEntityIdentifier($newVal);
  567.             }
  568.             $targetClass $this->em->getClassMetadata($assoc['targetEntity']);
  569.             $owningTable $this->getOwningTable($field);
  570.             foreach ($assoc['joinColumns'] as $joinColumn) {
  571.                 $sourceColumn $joinColumn['name'];
  572.                 $targetColumn $joinColumn['referencedColumnName'];
  573.                 $quotedColumn $this->quoteStrategy->getJoinColumnName($joinColumn$this->class$this->platform);
  574.                 $this->quotedColumns[$sourceColumn]  = $quotedColumn;
  575.                 $this->columnTypes[$sourceColumn]    = PersisterHelper::getTypeOfColumn($targetColumn$targetClass$this->em);
  576.                 $result[$owningTable][$sourceColumn] = $newValId
  577.                     $newValId[$targetClass->getFieldForColumn($targetColumn)]
  578.                     : null;
  579.             }
  580.         }
  581.         return $result;
  582.     }
  583.     /**
  584.      * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
  585.      * The changeset of the entity is obtained from the currently running UnitOfWork.
  586.      *
  587.      * The default insert data preparation is the same as for updates.
  588.      *
  589.      * @param object $entity The entity for which to prepare the data.
  590.      *
  591.      * @return mixed[][] The prepared data for the tables to update.
  592.      *
  593.      * @see prepareUpdateData
  594.      *
  595.      * @psalm-return array<string, mixed[]>
  596.      */
  597.     protected function prepareInsertData($entity)
  598.     {
  599.         return $this->prepareUpdateData($entity);
  600.     }
  601.     /**
  602.      * {@inheritdoc}
  603.      */
  604.     public function getOwningTable($fieldName)
  605.     {
  606.         return $this->class->getTableName();
  607.     }
  608.     /**
  609.      * {@inheritdoc}
  610.      */
  611.     public function load(array $criteria$entity null$assoc null, array $hints = [], $lockMode null$limit null, array $orderBy null)
  612.     {
  613.         $this->switchPersisterContext(null$limit);
  614.         $sql $this->getSelectSQL($criteria$assoc$lockMode$limitnull$orderBy);
  615.         [$params$types] = $this->expandParameters($criteria);
  616.         $stmt $this->conn->executeQuery($sql$params$types);
  617.         if ($entity !== null) {
  618.             $hints[Query::HINT_REFRESH]         = true;
  619.             $hints[Query::HINT_REFRESH_ENTITY]  = $entity;
  620.         }
  621.         $hydrator $this->em->newHydrator($this->currentPersisterContext->selectJoinSql Query::HYDRATE_OBJECT Query::HYDRATE_SIMPLEOBJECT);
  622.         $entities $hydrator->hydrateAll($stmt$this->currentPersisterContext->rsm$hints);
  623.         return $entities $entities[0] : null;
  624.     }
  625.     /**
  626.      * {@inheritdoc}
  627.      */
  628.     public function loadById(array $identifier$entity null)
  629.     {
  630.         return $this->load($identifier$entity);
  631.     }
  632.     /**
  633.      * {@inheritdoc}
  634.      */
  635.     public function loadOneToOneEntity(array $assoc$sourceEntity, array $identifier = [])
  636.     {
  637.         if (($foundEntity $this->em->getUnitOfWork()->tryGetById($identifier$assoc['targetEntity'])) != false) {
  638.             return $foundEntity;
  639.         }
  640.         $targetClass $this->em->getClassMetadata($assoc['targetEntity']);
  641.         if ($assoc['isOwningSide']) {
  642.             $isInverseSingleValued $assoc['inversedBy'] && ! $targetClass->isCollectionValuedAssociation($assoc['inversedBy']);
  643.             // Mark inverse side as fetched in the hints, otherwise the UoW would
  644.             // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
  645.             $hints = [];
  646.             if ($isInverseSingleValued) {
  647.                 $hints['fetched']["r"][$assoc['inversedBy']] = true;
  648.             }
  649.             /* cascade read-only status
  650.             if ($this->em->getUnitOfWork()->isReadOnly($sourceEntity)) {
  651.                 $hints[Query::HINT_READ_ONLY] = true;
  652.             }
  653.             */
  654.             $targetEntity $this->load($identifiernull$assoc$hints);
  655.             // Complete bidirectional association, if necessary
  656.             if ($targetEntity !== null && $isInverseSingleValued) {
  657.                 $targetClass->reflFields[$assoc['inversedBy']]->setValue($targetEntity$sourceEntity);
  658.             }
  659.             return $targetEntity;
  660.         }
  661.         $sourceClass $this->em->getClassMetadata($assoc['sourceEntity']);
  662.         $owningAssoc $targetClass->getAssociationMapping($assoc['mappedBy']);
  663.         $computedIdentifier = [];
  664.         // TRICKY: since the association is specular source and target are flipped
  665.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  666.             if ( ! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
  667.                 throw MappingException::joinColumnMustPointToMappedField(
  668.                     $sourceClass->name$sourceKeyColumn
  669.                 );
  670.             }
  671.             $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  672.                 $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
  673.         }
  674.         $targetEntity $this->load($computedIdentifiernull$assoc);
  675.         if ($targetEntity !== null) {
  676.             $targetClass->setFieldValue($targetEntity$assoc['mappedBy'], $sourceEntity);
  677.         }
  678.         return $targetEntity;
  679.     }
  680.     /**
  681.      * {@inheritdoc}
  682.      */
  683.     public function refresh(array $id$entity$lockMode null)
  684.     {
  685.         $sql $this->getSelectSQL($idnull$lockMode);
  686.         [$params$types] = $this->expandParameters($id);
  687.         $stmt $this->conn->executeQuery($sql$params$types);
  688.         $hydrator $this->em->newHydrator(Query::HYDRATE_OBJECT);
  689.         $hydrator->hydrateAll($stmt$this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
  690.     }
  691.     /**
  692.      * {@inheritDoc}
  693.      */
  694.     public function count($criteria = [])
  695.     {
  696.         $sql $this->getCountSQL($criteria);
  697.         [$params$types] = $criteria instanceof Criteria
  698.             $this->expandCriteriaParameters($criteria)
  699.             : $this->expandParameters($criteria);
  700.         return (int) $this->conn->executeQuery($sql$params$types)->fetchColumn();
  701.     }
  702.     /**
  703.      * {@inheritdoc}
  704.      */
  705.     public function loadCriteria(Criteria $criteria)
  706.     {
  707.         $orderBy $criteria->getOrderings();
  708.         $limit   $criteria->getMaxResults();
  709.         $offset  $criteria->getFirstResult();
  710.         $query   $this->getSelectSQL($criterianullnull$limit$offset$orderBy);
  711.         [$params$types] = $this->expandCriteriaParameters($criteria);
  712.         $stmt       $this->conn->executeQuery($query$params$types);
  713.         $hydrator   $this->em->newHydrator(($this->currentPersisterContext->selectJoinSql) ? Query::HYDRATE_OBJECT Query::HYDRATE_SIMPLEOBJECT);
  714.         return $hydrator->hydrateAll($stmt$this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]
  715.         );
  716.     }
  717.     /**
  718.      * {@inheritdoc}
  719.      */
  720.     public function expandCriteriaParameters(Criteria $criteria)
  721.     {
  722.         $expression $criteria->getWhereExpression();
  723.         $sqlParams  = [];
  724.         $sqlTypes   = [];
  725.         if ($expression === null) {
  726.             return [$sqlParams$sqlTypes];
  727.         }
  728.         $valueVisitor = new SqlValueVisitor();
  729.         $valueVisitor->dispatch($expression);
  730.         [$params$types] = $valueVisitor->getParamsAndTypes();
  731.         foreach ($params as $param) {
  732.             $sqlParams array_merge($sqlParams$this->getValues($param));
  733.         }
  734.         foreach ($types as $type) {
  735.             [$field$value] = $type;
  736.             $sqlTypes array_merge($sqlTypes$this->getTypes($field$value$this->class));
  737.         }
  738.         return [$sqlParams$sqlTypes];
  739.     }
  740.     /**
  741.      * {@inheritdoc}
  742.      */
  743.     public function loadAll(array $criteria = [], array $orderBy null$limit null$offset null)
  744.     {
  745.         $this->switchPersisterContext($offset$limit);
  746.         $sql $this->getSelectSQL($criterianullnull$limit$offset$orderBy);
  747.         [$params$types] = $this->expandParameters($criteria);
  748.         $stmt $this->conn->executeQuery($sql$params$types);
  749.         $hydrator $this->em->newHydrator(($this->currentPersisterContext->selectJoinSql) ? Query::HYDRATE_OBJECT Query::HYDRATE_SIMPLEOBJECT);
  750.         return $hydrator->hydrateAll($stmt$this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]
  751.         );
  752.     }
  753.     /**
  754.      * {@inheritdoc}
  755.      */
  756.     public function getManyToManyCollection(array $assoc$sourceEntity$offset null$limit null)
  757.     {
  758.         $this->switchPersisterContext($offset$limit);
  759.         $stmt $this->getManyToManyStatement($assoc$sourceEntity$offset$limit);
  760.         return $this->loadArrayFromStatement($assoc$stmt);
  761.     }
  762.     /**
  763.      * Loads an array of entities from a given DBAL statement.
  764.      *
  765.      * @param array                    $assoc
  766.      * @param \Doctrine\DBAL\Statement $stmt
  767.      *
  768.      * @return array
  769.      */
  770.     private function loadArrayFromStatement($assoc$stmt)
  771.     {
  772.         $rsm    $this->currentPersisterContext->rsm;
  773.         $hints  = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
  774.         if (isset($assoc['indexBy'])) {
  775.             $rsm = clone ($this->currentPersisterContext->rsm); // this is necessary because the "default rsm" should be changed.
  776.             $rsm->addIndexBy('r'$assoc['indexBy']);
  777.         }
  778.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt$rsm$hints);
  779.     }
  780.     /**
  781.      * Hydrates a collection from a given DBAL statement.
  782.      *
  783.      * @param array                    $assoc
  784.      * @param \Doctrine\DBAL\Statement $stmt
  785.      * @param PersistentCollection     $coll
  786.      *
  787.      * @return array
  788.      */
  789.     private function loadCollectionFromStatement($assoc$stmt$coll)
  790.     {
  791.         $rsm   $this->currentPersisterContext->rsm;
  792.         $hints = [
  793.             UnitOfWork::HINT_DEFEREAGERLOAD => true,
  794.             'collection' => $coll
  795.         ];
  796.         if (isset($assoc['indexBy'])) {
  797.             $rsm = clone ($this->currentPersisterContext->rsm); // this is necessary because the "default rsm" should be changed.
  798.             $rsm->addIndexBy('r'$assoc['indexBy']);
  799.         }
  800.         return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt$rsm$hints);
  801.     }
  802.     /**
  803.      * {@inheritdoc}
  804.      */
  805.     public function loadManyToManyCollection(array $assoc$sourceEntityPersistentCollection $collection)
  806.     {
  807.         $stmt $this->getManyToManyStatement($assoc$sourceEntity);
  808.         return $this->loadCollectionFromStatement($assoc$stmt$collection);
  809.     }
  810.     /**
  811.      * @param array    $assoc
  812.      * @param object   $sourceEntity
  813.      * @param int|null $offset
  814.      * @param int|null $limit
  815.      *
  816.      * @return \Doctrine\DBAL\Driver\Statement
  817.      *
  818.      * @throws \Doctrine\ORM\Mapping\MappingException
  819.      */
  820.     private function getManyToManyStatement(array $assoc$sourceEntity$offset null$limit null)
  821.     {
  822.         $this->switchPersisterContext($offset$limit);
  823.         $sourceClass    $this->em->getClassMetadata($assoc['sourceEntity']);
  824.         $class          $sourceClass;
  825.         $association    $assoc;
  826.         $criteria       = [];
  827.         $parameters     = [];
  828.         if ( ! $assoc['isOwningSide']) {
  829.             $class       $this->em->getClassMetadata($assoc['targetEntity']);
  830.             $association $class->associationMappings[$assoc['mappedBy']];
  831.         }
  832.         $joinColumns $assoc['isOwningSide']
  833.             ? $association['joinTable']['joinColumns']
  834.             : $association['joinTable']['inverseJoinColumns'];
  835.         $quotedJoinTable $this->quoteStrategy->getJoinTableName($association$class$this->platform);
  836.         foreach ($joinColumns as $joinColumn) {
  837.             $sourceKeyColumn    $joinColumn['referencedColumnName'];
  838.             $quotedKeyColumn    $this->quoteStrategy->getJoinColumnName($joinColumn$class$this->platform);
  839.             switch (true) {
  840.                 case $sourceClass->containsForeignIdentifier:
  841.                     $field $sourceClass->getFieldForColumn($sourceKeyColumn);
  842.                     $value $sourceClass->reflFields[$field]->getValue($sourceEntity);
  843.                     if (isset($sourceClass->associationMappings[$field])) {
  844.                         $value $this->em->getUnitOfWork()->getEntityIdentifier($value);
  845.                         $value $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  846.                     }
  847.                     break;
  848.                 case isset($sourceClass->fieldNames[$sourceKeyColumn]):
  849.                     $field $sourceClass->fieldNames[$sourceKeyColumn];
  850.                     $value $sourceClass->reflFields[$field]->getValue($sourceEntity);
  851.                     break;
  852.                 default:
  853.                     throw MappingException::joinColumnMustPointToMappedField(
  854.                         $sourceClass->name$sourceKeyColumn
  855.                     );
  856.             }
  857.             $criteria[$quotedJoinTable '.' $quotedKeyColumn] = $value;
  858.             $parameters[] = [
  859.                 'value' => $value,
  860.                 'field' => $field,
  861.                 'class' => $sourceClass,
  862.             ];
  863.         }
  864.         $sql $this->getSelectSQL($criteria$assocnull$limit$offset);
  865.         [$params$types] = $this->expandToManyParameters($parameters);
  866.         return $this->conn->executeQuery($sql$params$types);
  867.     }
  868.     /**
  869.      * {@inheritdoc}
  870.      */
  871.     public function getSelectSQL($criteria$assoc null$lockMode null$limit null$offset null, array $orderBy null)
  872.     {
  873.         $this->switchPersisterContext($offset$limit);
  874.         $lockSql    '';
  875.         $joinSql    '';
  876.         $orderBySql '';
  877.         if ($assoc != null && $assoc['type'] == ClassMetadata::MANY_TO_MANY) {
  878.             $joinSql $this->getSelectManyToManyJoinSQL($assoc);
  879.         }
  880.         if (isset($assoc['orderBy'])) {
  881.             $orderBy $assoc['orderBy'];
  882.         }
  883.         if ($orderBy) {
  884.             $orderBySql $this->getOrderBySQL($orderBy$this->getSQLTableAlias($this->class->name));
  885.         }
  886.         $conditionSql = ($criteria instanceof Criteria)
  887.             ? $this->getSelectConditionCriteriaSQL($criteria)
  888.             : $this->getSelectConditionSQL($criteria$assoc);
  889.         switch ($lockMode) {
  890.             case LockMode::PESSIMISTIC_READ:
  891.                 $lockSql ' ' $this->platform->getReadLockSQL();
  892.                 break;
  893.             case LockMode::PESSIMISTIC_WRITE:
  894.                 $lockSql ' ' $this->platform->getWriteLockSQL();
  895.                 break;
  896.         }
  897.         $columnList $this->getSelectColumnsSQL();
  898.         $tableAlias $this->getSQLTableAlias($this->class->name);
  899.         $filterSql  $this->generateFilterConditionSQL($this->class$tableAlias);
  900.         $tableName  $this->quoteStrategy->getTableName($this->class$this->platform);
  901.         if ('' !== $filterSql) {
  902.             $conditionSql $conditionSql
  903.                 $conditionSql ' AND ' $filterSql
  904.                 $filterSql;
  905.         }
  906.         $select 'SELECT ' $columnList;
  907.         $from   ' FROM ' $tableName ' '$tableAlias;
  908.         $join   $this->currentPersisterContext->selectJoinSql $joinSql;
  909.         $where  = ($conditionSql ' WHERE ' $conditionSql '');
  910.         $lock   $this->platform->appendLockHint($from$lockMode);
  911.         $query  $select
  912.             $lock
  913.             $join
  914.             $where
  915.             $orderBySql;
  916.         return $this->platform->modifyLimitQuery($query$limit$offset) . $lockSql;
  917.     }
  918.     /**
  919.      * {@inheritDoc}
  920.      */
  921.     public function getCountSQL($criteria = [])
  922.     {
  923.         $tableName  $this->quoteStrategy->getTableName($this->class$this->platform);
  924.         $tableAlias $this->getSQLTableAlias($this->class->name);
  925.         $conditionSql = ($criteria instanceof Criteria)
  926.             ? $this->getSelectConditionCriteriaSQL($criteria)
  927.             : $this->getSelectConditionSQL($criteria);
  928.         $filterSql $this->generateFilterConditionSQL($this->class$tableAlias);
  929.         if ('' !== $filterSql) {
  930.             $conditionSql $conditionSql
  931.                 $conditionSql ' AND ' $filterSql
  932.                 $filterSql;
  933.         }
  934.         $sql 'SELECT COUNT(*) '
  935.             'FROM ' $tableName ' ' $tableAlias
  936.             . (empty($conditionSql) ? '' ' WHERE ' $conditionSql);
  937.         return $sql;
  938.     }
  939.     /**
  940.      * Gets the ORDER BY SQL snippet for ordered collections.
  941.      *
  942.      * @param array  $orderBy
  943.      * @param string $baseTableAlias
  944.      *
  945.      * @return string
  946.      *
  947.      * @throws \Doctrine\ORM\ORMException
  948.      */
  949.     final protected function getOrderBySQL(array $orderBy$baseTableAlias) : string
  950.     {
  951.         $orderByList = [];
  952.         foreach ($orderBy as $fieldName => $orientation) {
  953.             $orientation strtoupper(trim($orientation));
  954.             if ($orientation != 'ASC' && $orientation != 'DESC') {
  955.                 throw ORMException::invalidOrientation($this->class->name$fieldName);
  956.             }
  957.             if (isset($this->class->fieldMappings[$fieldName])) {
  958.                 $tableAlias = isset($this->class->fieldMappings[$fieldName]['inherited'])
  959.                     ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
  960.                     : $baseTableAlias;
  961.                 $columnName    $this->quoteStrategy->getColumnName($fieldName$this->class$this->platform);
  962.                 $orderByList[] = $tableAlias '.' $columnName ' ' $orientation;
  963.                 continue;
  964.             }
  965.             if (isset($this->class->associationMappings[$fieldName])) {
  966.                 if ( ! $this->class->associationMappings[$fieldName]['isOwningSide']) {
  967.                     throw ORMException::invalidFindByInverseAssociation($this->class->name$fieldName);
  968.                 }
  969.                 $tableAlias = isset($this->class->associationMappings[$fieldName]['inherited'])
  970.                     ? $this->getSQLTableAlias($this->class->associationMappings[$fieldName]['inherited'])
  971.                     : $baseTableAlias;
  972.                 foreach ($this->class->associationMappings[$fieldName]['joinColumns'] as $joinColumn) {
  973.                     $columnName    $this->quoteStrategy->getJoinColumnName($joinColumn$this->class$this->platform);
  974.                     $orderByList[] = $tableAlias '.' $columnName ' ' $orientation;
  975.                 }
  976.                 continue;
  977.             }
  978.             throw ORMException::unrecognizedField($fieldName);
  979.         }
  980.         return ' ORDER BY ' implode(', '$orderByList);
  981.     }
  982.     /**
  983.      * Gets the SQL fragment with the list of columns to select when querying for
  984.      * an entity in this persister.
  985.      *
  986.      * Subclasses should override this method to alter or change the select column
  987.      * list SQL fragment. Note that in the implementation of BasicEntityPersister
  988.      * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
  989.      * Subclasses may or may not do the same.
  990.      *
  991.      * @return string The SQL fragment.
  992.      */
  993.     protected function getSelectColumnsSQL()
  994.     {
  995.         if ($this->currentPersisterContext->selectColumnListSql !== null) {
  996.             return $this->currentPersisterContext->selectColumnListSql;
  997.         }
  998.         $columnList = [];
  999.         $this->currentPersisterContext->rsm->addEntityResult($this->class->name'r'); // r for root
  1000.         // Add regular columns to select list
  1001.         foreach ($this->class->fieldNames as $field) {
  1002.             $columnList[] = $this->getSelectColumnSQL($field$this->class);
  1003.         }
  1004.         $this->currentPersisterContext->selectJoinSql    '';
  1005.         $eagerAliasCounter      0;
  1006.         foreach ($this->class->associationMappings as $assocField => $assoc) {
  1007.             $assocColumnSQL $this->getSelectColumnAssociationSQL($assocField$assoc$this->class);
  1008.             if ($assocColumnSQL) {
  1009.                 $columnList[] = $assocColumnSQL;
  1010.             }
  1011.             $isAssocToOneInverseSide $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
  1012.             $isAssocFromOneEager     $assoc['type'] !== ClassMetadata::MANY_TO_MANY && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
  1013.             if ( ! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
  1014.                 continue;
  1015.             }
  1016.             if ((($assoc['type'] & ClassMetadata::TO_MANY) > 0) && $this->currentPersisterContext->handlesLimits) {
  1017.                 continue;
  1018.             }
  1019.             $eagerEntity $this->em->getClassMetadata($assoc['targetEntity']);
  1020.             if ($eagerEntity->inheritanceType != ClassMetadata::INHERITANCE_TYPE_NONE) {
  1021.                 continue; // now this is why you shouldn't use inheritance
  1022.             }
  1023.             $assocAlias 'e' . ($eagerAliasCounter++);
  1024.             $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc['targetEntity'], $assocAlias'r'$assocField);
  1025.             foreach ($eagerEntity->fieldNames as $field) {
  1026.                 $columnList[] = $this->getSelectColumnSQL($field$eagerEntity$assocAlias);
  1027.             }
  1028.             foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
  1029.                 $eagerAssocColumnSQL $this->getSelectColumnAssociationSQL(
  1030.                     $eagerAssocField$eagerAssoc$eagerEntity$assocAlias
  1031.                 );
  1032.                 if ($eagerAssocColumnSQL) {
  1033.                     $columnList[] = $eagerAssocColumnSQL;
  1034.                 }
  1035.             }
  1036.             $association    $assoc;
  1037.             $joinCondition  = [];
  1038.             if (isset($assoc['indexBy'])) {
  1039.                 $this->currentPersisterContext->rsm->addIndexBy($assocAlias$assoc['indexBy']);
  1040.             }
  1041.             if ( ! $assoc['isOwningSide']) {
  1042.                 $eagerEntity $this->em->getClassMetadata($assoc['targetEntity']);
  1043.                 $association $eagerEntity->getAssociationMapping($assoc['mappedBy']);
  1044.             }
  1045.             $joinTableAlias $this->getSQLTableAlias($eagerEntity->name$assocAlias);
  1046.             $joinTableName  $this->quoteStrategy->getTableName($eagerEntity$this->platform);
  1047.             if ($assoc['isOwningSide']) {
  1048.                 $tableAlias           $this->getSQLTableAlias($association['targetEntity'], $assocAlias);
  1049.                 $this->currentPersisterContext->selectJoinSql .= ' ' $this->getJoinSQLForJoinColumns($association['joinColumns']);
  1050.                 foreach ($association['joinColumns'] as $joinColumn) {
  1051.                     $sourceCol       $this->quoteStrategy->getJoinColumnName($joinColumn$this->class$this->platform);
  1052.                     $targetCol       $this->quoteStrategy->getReferencedJoinColumnName($joinColumn$this->class$this->platform);
  1053.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'])
  1054.                                         . '.' $sourceCol ' = ' $tableAlias '.' $targetCol;
  1055.                 }
  1056.                 // Add filter SQL
  1057.                 if ($filterSql $this->generateFilterConditionSQL($eagerEntity$tableAlias)) {
  1058.                     $joinCondition[] = $filterSql;
  1059.                 }
  1060.             } else {
  1061.                 $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
  1062.                 foreach ($association['joinColumns'] as $joinColumn) {
  1063.                     $sourceCol       $this->quoteStrategy->getJoinColumnName($joinColumn$this->class$this->platform);
  1064.                     $targetCol       $this->quoteStrategy->getReferencedJoinColumnName($joinColumn$this->class$this->platform);
  1065.                     $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'], $assocAlias) . '.' $sourceCol ' = '
  1066.                         $this->getSQLTableAlias($association['targetEntity']) . '.' $targetCol;
  1067.                 }
  1068.             }
  1069.             $this->currentPersisterContext->selectJoinSql .= ' ' $joinTableName ' ' $joinTableAlias ' ON ';
  1070.             $this->currentPersisterContext->selectJoinSql .= implode(' AND '$joinCondition);
  1071.         }
  1072.         $this->currentPersisterContext->selectColumnListSql implode(', '$columnList);
  1073.         return $this->currentPersisterContext->selectColumnListSql;
  1074.     }
  1075.     /**
  1076.      * Gets the SQL join fragment used when selecting entities from an association.
  1077.      *
  1078.      * @param string        $field
  1079.      * @param array         $assoc
  1080.      * @param ClassMetadata $class
  1081.      * @param string        $alias
  1082.      *
  1083.      * @return string
  1084.      */
  1085.     protected function getSelectColumnAssociationSQL($field$assocClassMetadata $class$alias 'r')
  1086.     {
  1087.         if ( ! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) ) {
  1088.             return '';
  1089.         }
  1090.         $columnList    = [];
  1091.         $targetClass   $this->em->getClassMetadata($assoc['targetEntity']);
  1092.         $isIdentifier  = isset($assoc['id']) && $assoc['id'] === true;
  1093.         $sqlTableAlias $this->getSQLTableAlias($class->name, ($alias == 'r' '' $alias));
  1094.         foreach ($assoc['joinColumns'] as $joinColumn) {
  1095.             $quotedColumn     $this->quoteStrategy->getJoinColumnName($joinColumn$this->class$this->platform);
  1096.             $resultColumnName $this->getSQLColumnAlias($joinColumn['name']);
  1097.             $type             PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass$this->em);
  1098.             $this->currentPersisterContext->rsm->addMetaResult($alias$resultColumnName$joinColumn['name'], $isIdentifier$type);
  1099.             $columnList[] = sprintf('%s.%s AS %s'$sqlTableAlias$quotedColumn$resultColumnName);
  1100.         }
  1101.         return implode(', '$columnList);
  1102.     }
  1103.     /**
  1104.      * Gets the SQL join fragment used when selecting entities from a
  1105.      * many-to-many association.
  1106.      *
  1107.      * @param array $manyToMany
  1108.      *
  1109.      * @return string
  1110.      */
  1111.     protected function getSelectManyToManyJoinSQL(array $manyToMany)
  1112.     {
  1113.         $conditions         = [];
  1114.         $association        $manyToMany;
  1115.         $sourceTableAlias   $this->getSQLTableAlias($this->class->name);
  1116.         if ( ! $manyToMany['isOwningSide']) {
  1117.             $targetEntity   $this->em->getClassMetadata($manyToMany['targetEntity']);
  1118.             $association    $targetEntity->associationMappings[$manyToMany['mappedBy']];
  1119.         }
  1120.         $joinTableName  $this->quoteStrategy->getJoinTableName($association$this->class$this->platform);
  1121.         $joinColumns    = ($manyToMany['isOwningSide'])
  1122.             ? $association['joinTable']['inverseJoinColumns']
  1123.             : $association['joinTable']['joinColumns'];
  1124.         foreach ($joinColumns as $joinColumn) {
  1125.             $quotedSourceColumn $this->quoteStrategy->getJoinColumnName($joinColumn$this->class$this->platform);
  1126.             $quotedTargetColumn $this->quoteStrategy->getReferencedJoinColumnName($joinColumn$this->class$this->platform);
  1127.             $conditions[]       = $sourceTableAlias '.' $quotedTargetColumn ' = ' $joinTableName '.' $quotedSourceColumn;
  1128.         }
  1129.         return ' INNER JOIN ' $joinTableName ' ON ' implode(' AND '$conditions);
  1130.     }
  1131.     /**
  1132.      * {@inheritdoc}
  1133.      */
  1134.     public function getInsertSQL()
  1135.     {
  1136.         if ($this->insertSql !== null) {
  1137.             return $this->insertSql;
  1138.         }
  1139.         $columns   $this->getInsertColumnList();
  1140.         $tableName $this->quoteStrategy->getTableName($this->class$this->platform);
  1141.         if (empty($columns)) {
  1142.             $identityColumn  $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class$this->platform);
  1143.             $this->insertSql $this->platform->getEmptyIdentityInsertSQL($tableName$identityColumn);
  1144.             return $this->insertSql;
  1145.         }
  1146.         $values  = [];
  1147.         $columns array_unique($columns);
  1148.         foreach ($columns as $column) {
  1149.             $placeholder '?';
  1150.             if (isset($this->class->fieldNames[$column])
  1151.                 && isset($this->columnTypes[$this->class->fieldNames[$column]])
  1152.                 && isset($this->class->fieldMappings[$this->class->fieldNames[$column]]['requireSQLConversion'])) {
  1153.                 $type        Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
  1154.                 $placeholder $type->convertToDatabaseValueSQL('?'$this->platform);
  1155.             }
  1156.             $values[] = $placeholder;
  1157.         }
  1158.         $columns implode(', '$columns);
  1159.         $values  implode(', '$values);
  1160.         $this->insertSql sprintf('INSERT INTO %s (%s) VALUES (%s)'$tableName$columns$values);
  1161.         return $this->insertSql;
  1162.     }
  1163.     /**
  1164.      * Gets the list of columns to put in the INSERT SQL statement.
  1165.      *
  1166.      * Subclasses should override this method to alter or change the list of
  1167.      * columns placed in the INSERT statements used by the persister.
  1168.      *
  1169.      * @return string[] The list of columns.
  1170.      *
  1171.      * @psalm-return list<string>
  1172.      */
  1173.     protected function getInsertColumnList()
  1174.     {
  1175.         $columns = [];
  1176.         foreach ($this->class->reflFields as $name => $field) {
  1177.             if ($this->class->isVersioned && $this->class->versionField == $name) {
  1178.                 continue;
  1179.             }
  1180.             if (isset($this->class->embeddedClasses[$name])) {
  1181.                 continue;
  1182.             }
  1183.             if (isset($this->class->associationMappings[$name])) {
  1184.                 $assoc $this->class->associationMappings[$name];
  1185.                 if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  1186.                     foreach ($assoc['joinColumns'] as $joinColumn) {
  1187.                         $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn$this->class$this->platform);
  1188.                     }
  1189.                 }
  1190.                 continue;
  1191.             }
  1192.             if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] != $name) {
  1193.                 $columns[]                = $this->quoteStrategy->getColumnName($name$this->class$this->platform);
  1194.                 $this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
  1195.             }
  1196.         }
  1197.         return $columns;
  1198.     }
  1199.     /**
  1200.      * Gets the SQL snippet of a qualified column name for the given field name.
  1201.      *
  1202.      * @param string        $field The field name.
  1203.      * @param ClassMetadata $class The class that declares this field. The table this class is
  1204.      *                             mapped to must own the column for the given field.
  1205.      * @param string        $alias
  1206.      *
  1207.      * @return string
  1208.      */
  1209.     protected function getSelectColumnSQL($fieldClassMetadata $class$alias 'r')
  1210.     {
  1211.         $root         $alias == 'r' '' $alias ;
  1212.         $tableAlias   $this->getSQLTableAlias($class->name$root);
  1213.         $fieldMapping $class->fieldMappings[$field];
  1214.         $sql          sprintf('%s.%s'$tableAlias$this->quoteStrategy->getColumnName($field$class$this->platform));
  1215.         $columnAlias  $this->getSQLColumnAlias($fieldMapping['columnName']);
  1216.         $this->currentPersisterContext->rsm->addFieldResult($alias$columnAlias$field);
  1217.         if (isset($fieldMapping['requireSQLConversion'])) {
  1218.             $type Type::getType($fieldMapping['type']);
  1219.             $sql  $type->convertToPHPValueSQL($sql$this->platform);
  1220.         }
  1221.         return $sql ' AS ' $columnAlias;
  1222.     }
  1223.     /**
  1224.      * Gets the SQL table alias for the given class name.
  1225.      *
  1226.      * @param string $className
  1227.      * @param string $assocName
  1228.      *
  1229.      * @return string The SQL table alias.
  1230.      *
  1231.      * @todo Reconsider. Binding table aliases to class names is not such a good idea.
  1232.      */
  1233.     protected function getSQLTableAlias($className$assocName '')
  1234.     {
  1235.         if ($assocName) {
  1236.             $className .= '#' $assocName;
  1237.         }
  1238.         if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
  1239.             return $this->currentPersisterContext->sqlTableAliases[$className];
  1240.         }
  1241.         $tableAlias 't' $this->currentPersisterContext->sqlAliasCounter++;
  1242.         $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
  1243.         return $tableAlias;
  1244.     }
  1245.     /**
  1246.      * {@inheritdoc}
  1247.      */
  1248.     public function lock(array $criteria$lockMode)
  1249.     {
  1250.         $lockSql      '';
  1251.         $conditionSql $this->getSelectConditionSQL($criteria);
  1252.         switch ($lockMode) {
  1253.             case LockMode::PESSIMISTIC_READ:
  1254.                 $lockSql $this->platform->getReadLockSQL();
  1255.                 break;
  1256.             case LockMode::PESSIMISTIC_WRITE:
  1257.                 $lockSql $this->platform->getWriteLockSQL();
  1258.                 break;
  1259.         }
  1260.         $lock  $this->getLockTablesSql($lockMode);
  1261.         $where = ($conditionSql ' WHERE ' $conditionSql '') . ' ';
  1262.         $sql 'SELECT 1 '
  1263.              $lock
  1264.              $where
  1265.              $lockSql;
  1266.         [$params$types] = $this->expandParameters($criteria);
  1267.         $this->conn->executeQuery($sql$params$types);
  1268.     }
  1269.     /**
  1270.      * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
  1271.      *
  1272.      * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants.
  1273.      *
  1274.      * @return string
  1275.      */
  1276.     protected function getLockTablesSql($lockMode)
  1277.     {
  1278.         return $this->platform->appendLockHint(
  1279.             'FROM '
  1280.             $this->quoteStrategy->getTableName($this->class$this->platform) . ' '
  1281.             $this->getSQLTableAlias($this->class->name),
  1282.             $lockMode
  1283.         );
  1284.     }
  1285.     /**
  1286.      * Gets the Select Where Condition from a Criteria object.
  1287.      *
  1288.      * @param \Doctrine\Common\Collections\Criteria $criteria
  1289.      *
  1290.      * @return string
  1291.      */
  1292.     protected function getSelectConditionCriteriaSQL(Criteria $criteria)
  1293.     {
  1294.         $expression $criteria->getWhereExpression();
  1295.         if ($expression === null) {
  1296.             return '';
  1297.         }
  1298.         $visitor = new SqlExpressionVisitor($this$this->class);
  1299.         return $visitor->dispatch($expression);
  1300.     }
  1301.     /**
  1302.      * {@inheritdoc}
  1303.      */
  1304.     public function getSelectConditionStatementSQL($field$value$assoc null$comparison null)
  1305.     {
  1306.         $selectedColumns = [];
  1307.         $columns         $this->getSelectConditionStatementColumnSQL($field$assoc);
  1308.         if (count($columns) > && $comparison === Comparison::IN) {
  1309.             /*
  1310.              *  @todo try to support multi-column IN expressions.
  1311.              *  Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
  1312.              */
  1313.             throw ORMException::cantUseInOperatorOnCompositeKeys();
  1314.         }
  1315.         foreach ($columns as $column) {
  1316.             $placeholder '?';
  1317.             if (isset($this->class->fieldMappings[$field]['requireSQLConversion'])) {
  1318.                 $type        Type::getType($this->class->fieldMappings[$field]['type']);
  1319.                 $placeholder $type->convertToDatabaseValueSQL($placeholder$this->platform);
  1320.             }
  1321.             if (null !== $comparison) {
  1322.                 // special case null value handling
  1323.                 if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && null ===$value) {
  1324.                     $selectedColumns[] = $column ' IS NULL';
  1325.                     continue;
  1326.                 }
  1327.                 if ($comparison === Comparison::NEQ && null === $value) {
  1328.                     $selectedColumns[] = $column ' IS NOT NULL';
  1329.                     continue;
  1330.                 }
  1331.                 $selectedColumns[] = $column ' ' sprintf(self::$comparisonMap[$comparison], $placeholder);
  1332.                 continue;
  1333.             }
  1334.             if (is_array($value)) {
  1335.                 $in sprintf('%s IN (%s)'$column$placeholder);
  1336.                 if (false !== array_search(null$valuetrue)) {
  1337.                     $selectedColumns[] = sprintf('(%s OR %s IS NULL)'$in$column);
  1338.                     continue;
  1339.                 }
  1340.                 $selectedColumns[] = $in;
  1341.                 continue;
  1342.             }
  1343.             if (null === $value) {
  1344.                 $selectedColumns[] = sprintf('%s IS NULL'$column);
  1345.                 continue;
  1346.             }
  1347.             $selectedColumns[] = sprintf('%s = %s'$column$placeholder);
  1348.         }
  1349.         return implode(' AND '$selectedColumns);
  1350.     }
  1351.     /**
  1352.      * Builds the left-hand-side of a where condition statement.
  1353.      *
  1354.      * @param string     $field
  1355.      * @param array|null $assoc
  1356.      *
  1357.      * @return string[]
  1358.      *
  1359.      * @throws \Doctrine\ORM\ORMException
  1360.      *
  1361.      * @psalm-return list<string>
  1362.      */
  1363.     private function getSelectConditionStatementColumnSQL($field$assoc null)
  1364.     {
  1365.         if (isset($this->class->fieldMappings[$field])) {
  1366.             $className $this->class->fieldMappings[$field]['inherited'] ?? $this->class->name;
  1367.             return [$this->getSQLTableAlias($className) . '.' $this->quoteStrategy->getColumnName($field$this->class$this->platform)];
  1368.         }
  1369.         if (isset($this->class->associationMappings[$field])) {
  1370.             $association $this->class->associationMappings[$field];
  1371.             // Many-To-Many requires join table check for joinColumn
  1372.             $columns = [];
  1373.             $class   $this->class;
  1374.             if ($association['type'] === ClassMetadata::MANY_TO_MANY) {
  1375.                 if ( ! $association['isOwningSide']) {
  1376.                     $association $assoc;
  1377.                 }
  1378.                 $joinTableName $this->quoteStrategy->getJoinTableName($association$class$this->platform);
  1379.                 $joinColumns   $assoc['isOwningSide']
  1380.                     ? $association['joinTable']['joinColumns']
  1381.                     : $association['joinTable']['inverseJoinColumns'];
  1382.                 foreach ($joinColumns as $joinColumn) {
  1383.                     $columns[] = $joinTableName '.' $this->quoteStrategy->getJoinColumnName($joinColumn$class$this->platform);
  1384.                 }
  1385.             } else {
  1386.                 if ( ! $association['isOwningSide']) {
  1387.                     throw ORMException::invalidFindByInverseAssociation($this->class->name$field);
  1388.                 }
  1389.                 $className  = (isset($association['inherited']))
  1390.                     ? $association['inherited']
  1391.                     : $this->class->name;
  1392.                 foreach ($association['joinColumns'] as $joinColumn) {
  1393.                     $columns[] = $this->getSQLTableAlias($className) . '.' $this->quoteStrategy->getJoinColumnName($joinColumn$this->class$this->platform);
  1394.                 }
  1395.             }
  1396.             return $columns;
  1397.         }
  1398.         if ($assoc !== null && strpos($field" ") === false && strpos($field"(") === false) {
  1399.             // very careless developers could potentially open up this normally hidden api for userland attacks,
  1400.             // therefore checking for spaces and function calls which are not allowed.
  1401.             // found a join column condition, not really a "field"
  1402.             return [$field];
  1403.         }
  1404.         throw ORMException::unrecognizedField($field);
  1405.     }
  1406.     /**
  1407.      * Gets the conditional SQL fragment used in the WHERE clause when selecting
  1408.      * entities in this persister.
  1409.      *
  1410.      * Subclasses are supposed to override this method if they intend to change
  1411.      * or alter the criteria by which entities are selected.
  1412.      *
  1413.      * @param array      $criteria
  1414.      * @param array|null $assoc
  1415.      *
  1416.      * @return string
  1417.      */
  1418.     protected function getSelectConditionSQL(array $criteria$assoc null)
  1419.     {
  1420.         $conditions = [];
  1421.         foreach ($criteria as $field => $value) {
  1422.             $conditions[] = $this->getSelectConditionStatementSQL($field$value$assoc);
  1423.         }
  1424.         return implode(' AND '$conditions);
  1425.     }
  1426.     /**
  1427.      * {@inheritdoc}
  1428.      */
  1429.     public function getOneToManyCollection(array $assoc$sourceEntity$offset null$limit null)
  1430.     {
  1431.         $this->switchPersisterContext($offset$limit);
  1432.         $stmt $this->getOneToManyStatement($assoc$sourceEntity$offset$limit);
  1433.         return $this->loadArrayFromStatement($assoc$stmt);
  1434.     }
  1435.     /**
  1436.      * {@inheritdoc}
  1437.      */
  1438.     public function loadOneToManyCollection(array $assoc$sourceEntityPersistentCollection $collection)
  1439.     {
  1440.         $stmt $this->getOneToManyStatement($assoc$sourceEntity);
  1441.         return $this->loadCollectionFromStatement($assoc$stmt$collection);
  1442.     }
  1443.     /**
  1444.      * Builds criteria and execute SQL statement to fetch the one to many entities from.
  1445.      *
  1446.      * @param array    $assoc
  1447.      * @param object   $sourceEntity
  1448.      * @param int|null $offset
  1449.      * @param int|null $limit
  1450.      *
  1451.      * @return \Doctrine\DBAL\Statement
  1452.      */
  1453.     private function getOneToManyStatement(array $assoc$sourceEntity$offset null$limit null)
  1454.     {
  1455.         $this->switchPersisterContext($offset$limit);
  1456.         $criteria    = [];
  1457.         $parameters  = [];
  1458.         $owningAssoc $this->class->associationMappings[$assoc['mappedBy']];
  1459.         $sourceClass $this->em->getClassMetadata($assoc['sourceEntity']);
  1460.         $tableAlias  $this->getSQLTableAlias($owningAssoc['inherited'] ?? $this->class->name);
  1461.         foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  1462.             if ($sourceClass->containsForeignIdentifier) {
  1463.                 $field $sourceClass->getFieldForColumn($sourceKeyColumn);
  1464.                 $value $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1465.                 if (isset($sourceClass->associationMappings[$field])) {
  1466.                     $value $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1467.                     $value $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1468.                 }
  1469.                 $criteria[$tableAlias "." $targetKeyColumn] = $value;
  1470.                 $parameters[]                                   = [
  1471.                     'value' => $value,
  1472.                     'field' => $field,
  1473.                     'class' => $sourceClass,
  1474.                 ];
  1475.                 continue;
  1476.             }
  1477.             $field $sourceClass->fieldNames[$sourceKeyColumn];
  1478.             $value $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1479.             $criteria[$tableAlias "." $targetKeyColumn] = $value;
  1480.             $parameters[] = [
  1481.                 'value' => $value,
  1482.                 'field' => $field,
  1483.                 'class' => $sourceClass,
  1484.             ];
  1485.         }
  1486.         $sql                  $this->getSelectSQL($criteria$assocnull$limit$offset);
  1487.         [$params$types] = $this->expandToManyParameters($parameters);
  1488.         return $this->conn->executeQuery($sql$params$types);
  1489.     }
  1490.     /**
  1491.      * {@inheritdoc}
  1492.      */
  1493.     public function expandParameters($criteria)
  1494.     {
  1495.         $params = [];
  1496.         $types  = [];
  1497.         foreach ($criteria as $field => $value) {
  1498.             if ($value === null) {
  1499.                 continue; // skip null values.
  1500.             }
  1501.             $types  array_merge($types$this->getTypes($field$value$this->class));
  1502.             $params array_merge($params$this->getValues($value));
  1503.         }
  1504.         return [$params$types];
  1505.     }
  1506.     /**
  1507.      * Expands the parameters from the given criteria and use the correct binding types if found,
  1508.      * specialized for OneToMany or ManyToMany associations.
  1509.      *
  1510.      * @param mixed[][] $criteria an array of arrays containing following:
  1511.      *                             - field to which each criterion will be bound
  1512.      *                             - value to be bound
  1513.      *                             - class to which the field belongs to
  1514.      *
  1515.      * @return mixed[][]
  1516.      *
  1517.      * @psalm-return array{0: array, 1: list<mixed>}
  1518.      */
  1519.     private function expandToManyParameters($criteria)
  1520.     {
  1521.         $params = [];
  1522.         $types  = [];
  1523.         foreach ($criteria as $criterion) {
  1524.             if ($criterion['value'] === null) {
  1525.                 continue; // skip null values.
  1526.             }
  1527.             $types  array_merge($types$this->getTypes($criterion['field'], $criterion['value'], $criterion['class']));
  1528.             $params array_merge($params$this->getValues($criterion['value']));
  1529.         }
  1530.         return [$params$types];
  1531.     }
  1532.     /**
  1533.      * Infers field types to be used by parameter type casting.
  1534.      *
  1535.      * @param string        $field
  1536.      * @param mixed         $value
  1537.      * @param ClassMetadata $class
  1538.      *
  1539.      * @return int[]|null[]|string[]
  1540.      *
  1541.      * @throws \Doctrine\ORM\Query\QueryException
  1542.      *
  1543.      * @psalm-return list<int|null|string>
  1544.      */
  1545.     private function getTypes($field$valueClassMetadata $class)
  1546.     {
  1547.         $types = [];
  1548.         switch (true) {
  1549.             case (isset($class->fieldMappings[$field])):
  1550.                 $types array_merge($types, [$class->fieldMappings[$field]['type']]);
  1551.                 break;
  1552.             case (isset($class->associationMappings[$field])):
  1553.                 $assoc $class->associationMappings[$field];
  1554.                 $class $this->em->getClassMetadata($assoc['targetEntity']);
  1555.                 if (! $assoc['isOwningSide']) {
  1556.                     $assoc $class->associationMappings[$assoc['mappedBy']];
  1557.                     $class $this->em->getClassMetadata($assoc['targetEntity']);
  1558.                 }
  1559.                 $columns $assoc['type'] === ClassMetadata::MANY_TO_MANY
  1560.                     $assoc['relationToTargetKeyColumns']
  1561.                     : $assoc['sourceToTargetKeyColumns'];
  1562.                 foreach ($columns as $column){
  1563.                     $types[] = PersisterHelper::getTypeOfColumn($column$class$this->em);
  1564.                 }
  1565.                 break;
  1566.             default:
  1567.                 $types[] = null;
  1568.                 break;
  1569.         }
  1570.         if (is_array($value)) {
  1571.             return array_map(function ($type) {
  1572.                 $type Type::getType($type);
  1573.                 return $type->getBindingType() + Connection::ARRAY_PARAM_OFFSET;
  1574.             }, $types);
  1575.         }
  1576.         return $types;
  1577.     }
  1578.     /**
  1579.      * Retrieves the parameters that identifies a value.
  1580.      *
  1581.      * @param mixed $value
  1582.      *
  1583.      * @return array
  1584.      */
  1585.     private function getValues($value)
  1586.     {
  1587.         if (is_array($value)) {
  1588.             $newValue = [];
  1589.             foreach ($value as $itemValue) {
  1590.                 $newValue array_merge($newValue$this->getValues($itemValue));
  1591.             }
  1592.             return [$newValue];
  1593.         }
  1594.         if (is_object($value) && $this->em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($value))) {
  1595.             $class $this->em->getClassMetadata(get_class($value));
  1596.             if ($class->isIdentifierComposite) {
  1597.                 $newValue = [];
  1598.                 foreach ($class->getIdentifierValues($value) as $innerValue) {
  1599.                     $newValue array_merge($newValue$this->getValues($innerValue));
  1600.                 }
  1601.                 return $newValue;
  1602.             }
  1603.         }
  1604.         return [$this->getIndividualValue($value)];
  1605.     }
  1606.     /**
  1607.      * Retrieves an individual parameter value.
  1608.      *
  1609.      * @param mixed $value
  1610.      *
  1611.      * @return mixed
  1612.      */
  1613.     private function getIndividualValue($value)
  1614.     {
  1615.         if ( ! is_object($value) || ! $this->em->getMetadataFactory()->hasMetadataFor(ClassUtils::getClass($value))) {
  1616.             return $value;
  1617.         }
  1618.         return $this->em->getUnitOfWork()->getSingleIdentifierValue($value);
  1619.     }
  1620.     /**
  1621.      * {@inheritdoc}
  1622.      */
  1623.     public function exists($entityCriteria $extraConditions null)
  1624.     {
  1625.         $criteria $this->class->getIdentifierValues($entity);
  1626.         if ( ! $criteria) {
  1627.             return false;
  1628.         }
  1629.         $alias $this->getSQLTableAlias($this->class->name);
  1630.         $sql 'SELECT 1 '
  1631.              $this->getLockTablesSql(null)
  1632.              . ' WHERE ' $this->getSelectConditionSQL($criteria);
  1633.         [$params$types] = $this->expandParameters($criteria);
  1634.         if (null !== $extraConditions) {
  1635.             $sql                                 .= ' AND ' $this->getSelectConditionCriteriaSQL($extraConditions);
  1636.             [$criteriaParams$criteriaTypes] = $this->expandCriteriaParameters($extraConditions);
  1637.             $params array_merge($params$criteriaParams);
  1638.             $types  array_merge($types$criteriaTypes);
  1639.         }
  1640.         if ($filterSql $this->generateFilterConditionSQL($this->class$alias)) {
  1641.             $sql .= ' AND ' $filterSql;
  1642.         }
  1643.         return (bool) $this->conn->fetchColumn($sql$params0$types);
  1644.     }
  1645.     /**
  1646.      * Generates the appropriate join SQL for the given join column.
  1647.      *
  1648.      * @param array $joinColumns The join columns definition of an association.
  1649.      *
  1650.      * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
  1651.      */
  1652.     protected function getJoinSQLForJoinColumns($joinColumns)
  1653.     {
  1654.         // if one of the join columns is nullable, return left join
  1655.         foreach ($joinColumns as $joinColumn) {
  1656.              if ( ! isset($joinColumn['nullable']) || $joinColumn['nullable']) {
  1657.                  return 'LEFT JOIN';
  1658.              }
  1659.         }
  1660.         return 'INNER JOIN';
  1661.     }
  1662.     /**
  1663.      * @param string $columnName
  1664.      *
  1665.      * @return string
  1666.      */
  1667.     public function getSQLColumnAlias($columnName)
  1668.     {
  1669.         return $this->quoteStrategy->getColumnAlias($columnName$this->currentPersisterContext->sqlAliasCounter++, $this->platform);
  1670.     }
  1671.     /**
  1672.      * Generates the filter SQL for a given entity and table alias.
  1673.      *
  1674.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  1675.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  1676.      *
  1677.      * @return string The SQL query part to add to a query.
  1678.      */
  1679.     protected function generateFilterConditionSQL(ClassMetadata $targetEntity$targetTableAlias)
  1680.     {
  1681.         $filterClauses = [];
  1682.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  1683.             if ('' !== $filterExpr $filter->addFilterConstraint($targetEntity$targetTableAlias)) {
  1684.                 $filterClauses[] = '(' $filterExpr ')';
  1685.             }
  1686.         }
  1687.         $sql implode(' AND '$filterClauses);
  1688.         return $sql "(" $sql ")" ""// Wrap again to avoid "X or Y and FilterConditionSQL"
  1689.     }
  1690.     /**
  1691.      * Switches persister context according to current query offset/limits
  1692.      *
  1693.      * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
  1694.      *
  1695.      * @param null|int $offset
  1696.      * @param null|int $limit
  1697.      */
  1698.     protected function switchPersisterContext($offset$limit)
  1699.     {
  1700.         if (null === $offset && null === $limit) {
  1701.             $this->currentPersisterContext $this->noLimitsContext;
  1702.             return;
  1703.         }
  1704.         $this->currentPersisterContext $this->limitsHandlingContext;
  1705.     }
  1706.     /**
  1707.      * @return string[]
  1708.      */
  1709.     protected function getClassIdentifiersTypes(ClassMetadata $class) : array
  1710.     {
  1711.         $entityManager $this->em;
  1712.         return array_map(
  1713.             static function ($fieldName) use ($class$entityManager) : string {
  1714.                 $types PersisterHelper::getTypeOfField($fieldName$class$entityManager);
  1715.                 assert(isset($types[0]));
  1716.                 return $types[0];
  1717.             },
  1718.             $class->identifier
  1719.         );
  1720.     }
  1721. }