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

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Persisters\Entity;
  7. use Doctrine\Common\Collections\Criteria;
  8. use Doctrine\Common\Collections\Expr\Comparison;
  9. use Doctrine\DBAL\Connection;
  10. use Doctrine\DBAL\LockMode;
  11. use Doctrine\DBAL\Platforms\AbstractPlatform;
  12. use Doctrine\DBAL\Result;
  13. use Doctrine\DBAL\Types\Type;
  14. use Doctrine\DBAL\Types\Types;
  15. use Doctrine\Deprecations\Deprecation;
  16. use Doctrine\ORM\EntityManagerInterface;
  17. use Doctrine\ORM\Internal\CriteriaOrderings;
  18. use Doctrine\ORM\Mapping\ClassMetadata;
  19. use Doctrine\ORM\Mapping\MappingException;
  20. use Doctrine\ORM\Mapping\QuoteStrategy;
  21. use Doctrine\ORM\OptimisticLockException;
  22. use Doctrine\ORM\PersistentCollection;
  23. use Doctrine\ORM\Persisters\Exception\CantUseInOperatorOnCompositeKeys;
  24. use Doctrine\ORM\Persisters\Exception\InvalidOrientation;
  25. use Doctrine\ORM\Persisters\Exception\UnrecognizedField;
  26. use Doctrine\ORM\Persisters\SqlExpressionVisitor;
  27. use Doctrine\ORM\Persisters\SqlValueVisitor;
  28. use Doctrine\ORM\Query;
  29. use Doctrine\ORM\Repository\Exception\InvalidFindByCall;
  30. use Doctrine\ORM\UnitOfWork;
  31. use Doctrine\ORM\Utility\IdentifierFlattener;
  32. use Doctrine\ORM\Utility\LockSqlHelper;
  33. use Doctrine\ORM\Utility\PersisterHelper;
  34. use LengthException;
  36. use function array_combine;
  37. use function array_diff_key;
  38. use function array_fill;
  39. use function array_flip;
  40. use function array_keys;
  41. use function array_map;
  42. use function array_merge;
  43. use function array_unique;
  44. use function array_values;
  45. use function assert;
  46. use function count;
  47. use function implode;
  48. use function is_array;
  49. use function reset;
  50. use function spl_object_id;
  51. use function sprintf;
  52. use function str_contains;
  53. use function strtoupper;
  54. use function trim;
  56. /**
  57. * A BasicEntityPersister maps an entity to a single table in a relational database.
  58. *
  59. * A persister is always responsible for a single entity type.
  60. *
  61. * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
  62. * state of entities onto a relational database when the UnitOfWork is committed,
  63. * as well as for basic querying of entities and their associations (not DQL).
  64. *
  65. * The persisting operations that are invoked during a commit of a UnitOfWork to
  66. * persist the persistent entity state are:
  67. *
  68. * - {@link addInsert} : To schedule an entity for insertion.
  69. * - {@link executeInserts} : To execute all scheduled insertions.
  70. * - {@link update} : To update the persistent state of an entity.
  71. * - {@link delete} : To delete the persistent state of an entity.
  72. *
  73. * As can be seen from the above list, insertions are batched and executed all at once
  74. * for increased efficiency.
  75. *
  76. * The querying operations invoked during a UnitOfWork, either through direct find
  77. * requests or lazy-loading, are the following:
  78. *
  79. * - {@link load} : Loads (the state of) a single, managed entity.
  80. * - {@link loadAll} : Loads multiple, managed entities.
  81. * - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
  82. * - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
  83. * - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
  84. *
  85. * The BasicEntityPersister implementation provides the default behavior for
  86. * persisting and querying entities that are mapped to a single database table.
  87. *
  88. * Subclasses can be created to provide custom persisting and querying strategies,
  89. * i.e. spanning multiple tables.
  90. *
  91. * @phpstan-import-type AssociationMapping from ClassMetadata
  92. */
  93. class BasicEntityPersister implements EntityPersister
  94. {
  95. use CriteriaOrderings;
  96. use LockSqlHelper;
  98. /** @var array<string,string> */
  99. private static $comparisonMap = [
  100. Comparison::EQ => '= %s',
  101. Comparison::NEQ => '!= %s',
  102. Comparison::GT => '> %s',
  103. Comparison::GTE => '>= %s',
  104. Comparison::LT => '< %s',
  105. Comparison::LTE => '<= %s',
  106. Comparison::IN => 'IN (%s)',
  107. Comparison::NIN => 'NOT IN (%s)',
  108. Comparison::CONTAINS => 'LIKE %s',
  109. Comparison::STARTS_WITH => 'LIKE %s',
  110. Comparison::ENDS_WITH => 'LIKE %s',
  111. ];
  113. /**
  114. * Metadata object that describes the mapping of the mapped entity class.
  115. *
  116. * @var ClassMetadata
  117. */
  118. protected $class;
  120. /**
  121. * The underlying DBAL Connection of the used EntityManager.
  122. *
  123. * @var Connection $conn
  124. */
  125. protected $conn;
  127. /**
  128. * The database platform.
  129. *
  130. * @var AbstractPlatform
  131. */
  132. protected $platform;
  134. /**
  135. * The EntityManager instance.
  136. *
  137. * @var EntityManagerInterface
  138. */
  139. protected $em;
  141. /**
  142. * Queued inserts.
  143. *
  144. * @phpstan-var array<int, object>
  145. */
  146. protected $queuedInserts = [];
  148. /**
  149. * The map of column names to DBAL mapping types of all prepared columns used
  150. * when INSERTing or UPDATEing an entity.
  151. *
  152. * @see prepareInsertData($entity)
  153. * @see prepareUpdateData($entity)
  154. *
  155. * @var mixed[]
  156. */
  157. protected $columnTypes = [];
  159. /**
  160. * The map of quoted column names.
  161. *
  162. * @see prepareInsertData($entity)
  163. * @see prepareUpdateData($entity)
  164. *
  165. * @var mixed[]
  166. */
  167. protected $quotedColumns = [];
  169. /**
  170. * The quote strategy.
  171. *
  172. * @var QuoteStrategy
  173. */
  174. protected $quoteStrategy;
  176. /**
  177. * The IdentifierFlattener used for manipulating identifiers
  178. *
  179. * @var IdentifierFlattener
  180. */
  181. protected $identifierFlattener;
  183. /** @var CachedPersisterContext */
  184. protected $currentPersisterContext;
  186. /** @var CachedPersisterContext */
  187. private $limitsHandlingContext;
  189. /** @var CachedPersisterContext */
  190. private $noLimitsContext;
  192. /** @var ?string */
  193. private $filterHash = null;
  195. /**
  196. * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
  197. * and persists instances of the class described by the given ClassMetadata descriptor.
  198. */
  199. public function __construct(EntityManagerInterface $em, ClassMetadata $class)
  200. {
  201. $this->em = $em;
  202. $this->class = $class;
  203. $this->conn = $em->getConnection();
  204. $this->platform = $this->conn->getDatabasePlatform();
  205. $this->quoteStrategy = $em->getConfiguration()->getQuoteStrategy();
  206. $this->identifierFlattener = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
  207. $this->noLimitsContext = $this->currentPersisterContext = new CachedPersisterContext(
  208. $class,
  209. new Query\ResultSetMapping(),
  210. false
  211. );
  212. $this->limitsHandlingContext = new CachedPersisterContext(
  213. $class,
  214. new Query\ResultSetMapping(),
  215. true
  216. );
  217. }
  219. final protected function isFilterHashUpToDate(): bool
  220. {
  221. return $this->filterHash === $this->em->getFilters()->getHash();
  222. }
  224. final protected function updateFilterHash(): void
  225. {
  226. $this->filterHash = $this->em->getFilters()->getHash();
  227. }
  229. /**
  230. * {@inheritDoc}
  231. */
  232. public function getClassMetadata()
  233. {
  234. return $this->class;
  235. }
  237. /**
  238. * {@inheritDoc}
  239. */
  240. public function getResultSetMapping()
  241. {
  242. return $this->currentPersisterContext->rsm;
  243. }
  245. /**
  246. * {@inheritDoc}
  247. */
  248. public function addInsert($entity)
  249. {
  250. $this->queuedInserts[spl_object_id($entity)] = $entity;
  251. }
  253. /**
  254. * {@inheritDoc}
  255. */
  256. public function getInserts()
  257. {
  258. return $this->queuedInserts;
  259. }
  261. /**
  262. * {@inheritDoc}
  263. */
  264. public function executeInserts()
  265. {
  266. if (! $this->queuedInserts) {
  267. return;
  268. }
  270. $uow = $this->em->getUnitOfWork();
  271. $idGenerator = $this->class->idGenerator;
  272. $isPostInsertId = $idGenerator->isPostInsertGenerator();
  274. $stmt = $this->conn->prepare($this->getInsertSQL());
  275. $tableName = $this->class->getTableName();
  277. foreach ($this->queuedInserts as $key => $entity) {
  278. $insertData = $this->prepareInsertData($entity);
  280. if (isset($insertData[$tableName])) {
  281. $paramIndex = 1;
  283. foreach ($insertData[$tableName] as $column => $value) {
  284. $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$column]);
  285. }
  286. }
  288. $stmt->executeStatement();
  290. if ($isPostInsertId) {
  291. $generatedId = $idGenerator->generateId($this->em, $entity);
  292. $id = [$this->class->identifier[0] => $generatedId];
  294. $uow->assignPostInsertId($entity, $generatedId);
  295. } else {
  296. $id = $this->class->getIdentifierValues($entity);
  297. }
  299. if ($this->class->requiresFetchAfterChange) {
  300. $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  301. }
  303. // Unset this queued insert, so that the prepareUpdateData() method (called via prepareInsertData() method)
  304. // knows right away (for the next entity already) that the current entity has been written to the database
  305. // and no extra updates need to be scheduled to refer to it.
  306. //
  307. // In \Doctrine\ORM\UnitOfWork::executeInserts(), the UoW already removed entities
  308. // from its own list (\Doctrine\ORM\UnitOfWork::$entityInsertions) right after they
  309. // were given to our addInsert() method.
  310. unset($this->queuedInserts[$key]);
  311. }
  312. }
  314. /**
  315. * Retrieves the default version value which was created
  316. * by the preceding INSERT statement and assigns it back in to the
  317. * entities version field if the given entity is versioned.
  318. * Also retrieves values of columns marked as 'non insertable' and / or
  319. * 'not updatable' and assigns them back to the entities corresponding fields.
  320. *
  321. * @param object $entity
  322. * @param mixed[] $id
  323. *
  324. * @return void
  325. */
  326. protected function assignDefaultVersionAndUpsertableValues($entity, array $id)
  327. {
  328. $values = $this->fetchVersionAndNotUpsertableValues($this->class, $id);
  330. foreach ($values as $field => $value) {
  331. $value = Type::getType($this->class->fieldMappings[$field]['type'])->convertToPHPValue($value, $this->platform);
  333. $this->class->setFieldValue($entity, $field, $value);
  334. }
  335. }
  337. /**
  338. * Fetches the current version value of a versioned entity and / or the values of fields
  339. * marked as 'not insertable' and / or 'not updatable'.
  340. *
  341. * @param ClassMetadata $versionedClass
  342. * @param mixed[] $id
  343. *
  344. * @return mixed
  345. */
  346. protected function fetchVersionAndNotUpsertableValues($versionedClass, array $id)
  347. {
  348. $columnNames = [];
  349. foreach ($this->class->fieldMappings as $key => $column) {
  350. if (isset($column['generated']) || ($this->class->isVersioned && $key === $versionedClass->versionField)) {
  351. $columnNames[$key] = $this->quoteStrategy->getColumnName($key, $versionedClass, $this->platform);
  352. }
  353. }
  355. $tableName = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
  356. $identifier = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
  358. // FIXME: Order with composite keys might not be correct
  359. $sql = 'SELECT ' . implode(', ', $columnNames)
  360. . ' FROM ' . $tableName
  361. . ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
  363. $flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
  365. $values = $this->conn->fetchNumeric(
  366. $sql,
  367. array_values($flatId),
  368. $this->extractIdentifierTypes($id, $versionedClass)
  369. );
  371. if ($values === false) {
  372. throw new LengthException('Unexpected empty result for database query.');
  373. }
  375. $values = array_combine(array_keys($columnNames), $values);
  377. if (! $values) {
  378. throw new LengthException('Unexpected number of database columns.');
  379. }
  381. return $values;
  382. }
  384. /**
  385. * @param mixed[] $id
  386. *
  387. * @return int[]|null[]|string[]
  388. * @phpstan-return list<int|string|null>
  389. */
  390. final protected function extractIdentifierTypes(array $id, ClassMetadata $versionedClass): array
  391. {
  392. $types = [];
  394. foreach ($id as $field => $value) {
  395. $types = array_merge($types, PersisterHelper::inferParameterTypes($field, $value, $versionedClass, $this->em));
  396. }
  398. return $types;
  399. }
  401. /**
  402. * {@inheritDoc}
  403. */
  404. public function update($entity)
  405. {
  406. $tableName = $this->class->getTableName();
  407. $updateData = $this->prepareUpdateData($entity);
  409. if (! isset($updateData[$tableName])) {
  410. return;
  411. }
  413. $data = $updateData[$tableName];
  415. if (! $data) {
  416. return;
  417. }
  419. $isVersioned = $this->class->isVersioned;
  420. $quotedTableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  422. $this->updateTable($entity, $quotedTableName, $data, $isVersioned);
  424. if ($this->class->requiresFetchAfterChange) {
  425. $id = $this->class->getIdentifierValues($entity);
  427. $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  428. }
  429. }
  431. /**
  432. * Performs an UPDATE statement for an entity on a specific table.
  433. * The UPDATE can optionally be versioned, which requires the entity to have a version field.
  434. *
  435. * @param object $entity The entity object being updated.
  436. * @param string $quotedTableName The quoted name of the table to apply the UPDATE on.
  437. * @param mixed[] $updateData The map of columns to update (column => value).
  438. * @param bool $versioned Whether the UPDATE should be versioned.
  439. *
  440. * @throws UnrecognizedField
  441. * @throws OptimisticLockException
  442. */
  443. final protected function updateTable(
  444. $entity,
  445. $quotedTableName,
  446. array $updateData,
  447. $versioned = false
  448. ): void {
  449. $set = [];
  450. $types = [];
  451. $params = [];
  453. foreach ($updateData as $columnName => $value) {
  454. $placeholder = '?';
  455. $column = $columnName;
  457. switch (true) {
  458. case isset($this->class->fieldNames[$columnName]):
  459. $fieldName = $this->class->fieldNames[$columnName];
  460. $column = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  462. if (isset($this->class->fieldMappings[$fieldName]['requireSQLConversion'])) {
  463. $type = Type::getType($this->columnTypes[$columnName]);
  464. $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  465. }
  467. break;
  469. case isset($this->quotedColumns[$columnName]):
  470. $column = $this->quotedColumns[$columnName];
  472. break;
  473. }
  475. $params[] = $value;
  476. $set[] = $column . ' = ' . $placeholder;
  477. $types[] = $this->columnTypes[$columnName];
  478. }
  480. $where = [];
  481. $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  483. foreach ($this->class->identifier as $idField) {
  484. if (! isset($this->class->associationMappings[$idField])) {
  485. $params[] = $identifier[$idField];
  486. $types[] = $this->class->fieldMappings[$idField]['type'];
  487. $where[] = $this->quoteStrategy->getColumnName($idField, $this->class, $this->platform);
  489. continue;
  490. }
  492. $params[] = $identifier[$idField];
  493. $where[] = $this->quoteStrategy->getJoinColumnName(
  494. $this->class->associationMappings[$idField]['joinColumns'][0],
  495. $this->class,
  496. $this->platform
  497. );
  499. $targetMapping = $this->em->getClassMetadata($this->class->associationMappings[$idField]['targetEntity']);
  500. $targetType = PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping, $this->em);
  502. if ($targetType === []) {
  503. throw UnrecognizedField::byFullyQualifiedName($this->class->name, $targetMapping->identifier[0]);
  504. }
  506. $types[] = reset($targetType);
  507. }
  509. if ($versioned) {
  510. $versionField = $this->class->versionField;
  511. assert($versionField !== null);
  512. $versionFieldType = $this->class->fieldMappings[$versionField]['type'];
  513. $versionColumn = $this->quoteStrategy->getColumnName($versionField, $this->class, $this->platform);
  515. $where[] = $versionColumn;
  516. $types[] = $this->class->fieldMappings[$versionField]['type'];
  517. $params[] = $this->class->reflFields[$versionField]->getValue($entity);
  519. switch ($versionFieldType) {
  520. case Types::SMALLINT:
  521. case Types::INTEGER:
  522. case Types::BIGINT:
  523. $set[] = $versionColumn . ' = ' . $versionColumn . ' + 1';
  524. break;
  526. case Types::DATETIME_MUTABLE:
  527. $set[] = $versionColumn . ' = CURRENT_TIMESTAMP';
  528. break;
  529. }
  530. }
  532. $sql = 'UPDATE ' . $quotedTableName
  533. . ' SET ' . implode(', ', $set)
  534. . ' WHERE ' . implode(' = ? AND ', $where) . ' = ?';
  536. $result = $this->conn->executeStatement($sql, $params, $types);
  538. if ($versioned && ! $result) {
  539. throw OptimisticLockException::lockFailed($entity);
  540. }
  541. }
  543. /**
  544. * @param array<mixed> $identifier
  545. * @param string[] $types
  546. *
  547. * @todo Add check for platform if it supports foreign keys/cascading.
  548. */
  549. protected function deleteJoinTableRecords(array $identifier, array $types): void
  550. {
  551. foreach ($this->class->associationMappings as $mapping) {
  552. if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY || isset($mapping['isOnDeleteCascade'])) {
  553. continue;
  554. }
  556. // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
  557. // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
  558. $selfReferential = ($mapping['targetEntity'] === $mapping['sourceEntity']);
  559. $class = $this->class;
  560. $association = $mapping;
  561. $otherColumns = [];
  562. $otherKeys = [];
  563. $keys = [];
  565. if (! $mapping['isOwningSide']) {
  566. $class = $this->em->getClassMetadata($mapping['targetEntity']);
  567. $association = $class->associationMappings[$mapping['mappedBy']];
  568. }
  570. $joinColumns = $mapping['isOwningSide']
  571. ? $association['joinTable']['joinColumns']
  572. : $association['joinTable']['inverseJoinColumns'];
  574. if ($selfReferential) {
  575. $otherColumns = ! $mapping['isOwningSide']
  576. ? $association['joinTable']['joinColumns']
  577. : $association['joinTable']['inverseJoinColumns'];
  578. }
  580. foreach ($joinColumns as $joinColumn) {
  581. $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  582. }
  584. foreach ($otherColumns as $joinColumn) {
  585. $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  586. }
  588. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  590. $this->conn->delete($joinTableName, array_combine($keys, $identifier), $types);
  592. if ($selfReferential) {
  593. $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier), $types);
  594. }
  595. }
  596. }
  598. /**
  599. * {@inheritDoc}
  600. */
  601. public function delete($entity)
  602. {
  603. $class = $this->class;
  604. $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  605. $tableName = $this->quoteStrategy->getTableName($class, $this->platform);
  606. $idColumns = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform);
  607. $id = array_combine($idColumns, $identifier);
  608. $types = $this->getClassIdentifiersTypes($class);
  610. $this->deleteJoinTableRecords($identifier, $types);
  612. return (bool) $this->conn->delete($tableName, $id, $types);
  613. }
  615. /**
  616. * Prepares the changeset of an entity for database insertion (UPDATE).
  617. *
  618. * The changeset is obtained from the currently running UnitOfWork.
  619. *
  620. * During this preparation the array that is passed as the second parameter is filled with
  621. * <columnName> => <value> pairs, grouped by table name.
  622. *
  623. * Example:
  624. * <code>
  625. * array(
  626. * 'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
  627. * 'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
  628. * ...
  629. * )
  630. * </code>
  631. *
  632. * @param object $entity The entity for which to prepare the data.
  633. * @param bool $isInsert Whether the data to be prepared refers to an insert statement.
  634. *
  635. * @return mixed[][] The prepared data.
  636. * @phpstan-return array<string, array<array-key, mixed|null>>
  637. */
  638. protected function prepareUpdateData($entity, bool $isInsert = false)
  639. {
  640. $versionField = null;
  641. $result = [];
  642. $uow = $this->em->getUnitOfWork();
  644. $versioned = $this->class->isVersioned;
  645. if ($versioned !== false) {
  646. $versionField = $this->class->versionField;
  647. }
  649. foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
  650. if (isset($versionField) && $versionField === $field) {
  651. continue;
  652. }
  654. if (isset($this->class->embeddedClasses[$field])) {
  655. continue;
  656. }
  658. $newVal = $change[1];
  660. if (! isset($this->class->associationMappings[$field])) {
  661. $fieldMapping = $this->class->fieldMappings[$field];
  662. $columnName = $fieldMapping['columnName'];
  664. if (! $isInsert && isset($fieldMapping['notUpdatable'])) {
  665. continue;
  666. }
  668. if ($isInsert && isset($fieldMapping['notInsertable'])) {
  669. continue;
  670. }
  672. $this->columnTypes[$columnName] = $fieldMapping['type'];
  674. $result[$this->getOwningTable($field)][$columnName] = $newVal;
  676. continue;
  677. }
  679. $assoc = $this->class->associationMappings[$field];
  681. // Only owning side of x-1 associations can have a FK column.
  682. if (! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
  683. continue;
  684. }
  686. if ($newVal !== null) {
  687. $oid = spl_object_id($newVal);
  689. // If the associated entity $newVal is not yet persisted and/or does not yet have
  690. // an ID assigned, we must set $newVal = null. This will insert a null value and
  691. // schedule an extra update on the UnitOfWork.
  692. //
  693. // This gives us extra time to a) possibly obtain a database-generated identifier
  694. // value for $newVal, and b) insert $newVal into the database before the foreign
  695. // key reference is being made.
  696. //
  697. // When looking at $this->queuedInserts and $uow->isScheduledForInsert, be aware
  698. // of the implementation details that our own executeInserts() method will remove
  699. // entities from the former as soon as the insert statement has been executed and
  700. // a post-insert ID has been assigned (if necessary), and that the UnitOfWork has
  701. // already removed entities from its own list at the time they were passed to our
  702. // addInsert() method.
  703. //
  704. // Then, there is one extra exception we can make: An entity that references back to itself
  705. // _and_ uses an application-provided ID (the "NONE" generator strategy) also does not
  706. // need the extra update, although it is still in the list of insertions itself.
  707. // This looks like a minor optimization at first, but is the capstone for being able to
  708. // use non-NULLable, self-referencing associations in applications that provide IDs (like UUIDs).
  709. if (
  710. (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal))
  711. && ! ($newVal === $entity && $this->class->isIdentifierNatural())
  712. ) {
  713. $uow->scheduleExtraUpdate($entity, [$field => [null, $newVal]]);
  715. $newVal = null;
  716. }
  717. }
  719. $newValId = null;
  721. if ($newVal !== null) {
  722. $newValId = $uow->getEntityIdentifier($newVal);
  723. }
  725. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  726. $owningTable = $this->getOwningTable($field);
  728. foreach ($assoc['joinColumns'] as $joinColumn) {
  729. $sourceColumn = $joinColumn['name'];
  730. $targetColumn = $joinColumn['referencedColumnName'];
  731. $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  733. $this->quotedColumns[$sourceColumn] = $quotedColumn;
  734. $this->columnTypes[$sourceColumn] = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
  735. $result[$owningTable][$sourceColumn] = $newValId
  736. ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
  737. : null;
  738. }
  739. }
  741. return $result;
  742. }
  744. /**
  745. * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
  746. * The changeset of the entity is obtained from the currently running UnitOfWork.
  747. *
  748. * The default insert data preparation is the same as for updates.
  749. *
  750. * @see prepareUpdateData
  751. *
  752. * @param object $entity The entity for which to prepare the data.
  753. *
  754. * @return mixed[][] The prepared data for the tables to update.
  755. * @phpstan-return array<string, mixed[]>
  756. */
  757. protected function prepareInsertData($entity)
  758. {
  759. return $this->prepareUpdateData($entity, true);
  760. }
  762. /**
  763. * {@inheritDoc}
  764. */
  765. public function getOwningTable($fieldName)
  766. {
  767. return $this->class->getTableName();
  768. }
  770. /**
  771. * {@inheritDoc}
  772. */
  773. public function load(array $criteria, $entity = null, $assoc = null, array $hints = [], $lockMode = null, $limit = null, ?array $orderBy = null)
  774. {
  775. $this->switchPersisterContext(null, $limit);
  777. $sql = $this->getSelectSQL($criteria, $assoc, $lockMode, $limit, null, $orderBy);
  778. [$params, $types] = $this->expandParameters($criteria);
  779. $stmt = $this->conn->executeQuery($sql, $params, $types);
  781. if ($entity !== null) {
  782. $hints[Query::HINT_REFRESH] = true;
  783. $hints[Query::HINT_REFRESH_ENTITY] = $entity;
  784. }
  786. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  787. $entities = $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, $hints);
  789. return $entities ? $entities[0] : null;
  790. }
  792. /**
  793. * {@inheritDoc}
  794. */
  795. public function loadById(array $identifier, $entity = null)
  796. {
  797. return $this->load($identifier, $entity);
  798. }
  800. /**
  801. * {@inheritDoc}
  802. */
  803. public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
  804. {
  805. $foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc['targetEntity']);
  806. if ($foundEntity !== false) {
  807. return $foundEntity;
  808. }
  810. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  812. if ($assoc['isOwningSide']) {
  813. $isInverseSingleValued = $assoc['inversedBy'] && ! $targetClass->isCollectionValuedAssociation($assoc['inversedBy']);
  815. // Mark inverse side as fetched in the hints, otherwise the UoW would
  816. // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
  817. $hints = [];
  819. if ($isInverseSingleValued) {
  820. $hints['fetched']['r'][$assoc['inversedBy']] = true;
  821. }
  823. $targetEntity = $this->load($identifier, null, $assoc, $hints);
  825. // Complete bidirectional association, if necessary
  826. if ($targetEntity !== null && $isInverseSingleValued) {
  827. $targetClass->reflFields[$assoc['inversedBy']]->setValue($targetEntity, $sourceEntity);
  828. }
  830. return $targetEntity;
  831. }
  833. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  834. $owningAssoc = $targetClass->getAssociationMapping($assoc['mappedBy']);
  836. $computedIdentifier = [];
  838. /** @var array<string,mixed>|null $sourceEntityData */
  839. $sourceEntityData = null;
  841. // TRICKY: since the association is specular source and target are flipped
  842. foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  843. if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
  844. // The likely case here is that the column is a join column
  845. // in an association mapping. However, there is no guarantee
  846. // at this point that a corresponding (generally identifying)
  847. // association has been mapped in the source entity. To handle
  848. // this case we directly reference the column-keyed data used
  849. // to initialize the source entity before throwing an exception.
  850. $resolvedSourceData = false;
  851. if (! isset($sourceEntityData)) {
  852. $sourceEntityData = $this->em->getUnitOfWork()->getOriginalEntityData($sourceEntity);
  853. }
  855. if (isset($sourceEntityData[$sourceKeyColumn])) {
  856. $dataValue = $sourceEntityData[$sourceKeyColumn];
  857. if ($dataValue !== null) {
  858. $resolvedSourceData = true;
  859. $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  860. $dataValue;
  861. }
  862. }
  864. if (! $resolvedSourceData) {
  865. throw MappingException::joinColumnMustPointToMappedField(
  866. $sourceClass->name,
  867. $sourceKeyColumn
  868. );
  869. }
  870. } else {
  871. $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  872. $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
  873. }
  874. }
  876. $targetEntity = $this->load($computedIdentifier, null, $assoc);
  878. if ($targetEntity !== null) {
  879. $targetClass->setFieldValue($targetEntity, $assoc['mappedBy'], $sourceEntity);
  880. }
  882. return $targetEntity;
  883. }
  885. /**
  886. * {@inheritDoc}
  887. */
  888. public function refresh(array $id, $entity, $lockMode = null)
  889. {
  890. $sql = $this->getSelectSQL($id, null, $lockMode);
  891. [$params, $types] = $this->expandParameters($id);
  892. $stmt = $this->conn->executeQuery($sql, $params, $types);
  894. $hydrator = $this->em->newHydrator(Query::HYDRATE_OBJECT);
  895. $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
  896. }
  898. /**
  899. * {@inheritDoc}
  900. */
  901. public function count($criteria = [])
  902. {
  903. $sql = $this->getCountSQL($criteria);
  905. [$params, $types] = $criteria instanceof Criteria
  906. ? $this->expandCriteriaParameters($criteria)
  907. : $this->expandParameters($criteria);
  909. return (int) $this->conn->executeQuery($sql, $params, $types)->fetchOne();
  910. }
  912. /**
  913. * {@inheritDoc}
  914. */
  915. public function loadCriteria(Criteria $criteria)
  916. {
  917. $orderBy = self::getCriteriaOrderings($criteria);
  918. $limit = $criteria->getMaxResults();
  919. $offset = $criteria->getFirstResult();
  920. $query = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  922. [$params, $types] = $this->expandCriteriaParameters($criteria);
  924. $stmt = $this->conn->executeQuery($query, $params, $types);
  925. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  927. return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  928. }
  930. /**
  931. * {@inheritDoc}
  932. */
  933. public function expandCriteriaParameters(Criteria $criteria)
  934. {
  935. $expression = $criteria->getWhereExpression();
  936. $sqlParams = [];
  937. $sqlTypes = [];
  939. if ($expression === null) {
  940. return [$sqlParams, $sqlTypes];
  941. }
  943. $valueVisitor = new SqlValueVisitor();
  945. $valueVisitor->dispatch($expression);
  947. [, $types] = $valueVisitor->getParamsAndTypes();
  949. foreach ($types as $type) {
  950. [$field, $value, $operator] = $type;
  952. if ($value === null && ($operator === Comparison::EQ || $operator === Comparison::NEQ)) {
  953. continue;
  954. }
  956. if ($operator === Comparison::IN || $operator === Comparison::NIN) {
  957. if (! is_array($value)) {
  958. $value = [$value];
  959. }
  961. foreach ($value as $item) {
  962. if ($item === null) {
  963. /*
  964. * Compare this to how \Doctrine\ORM\Persisters\Entity\BasicEntityPersister::getSelectConditionStatementSQL
  965. * creates the "[NOT] IN (...)" expression - for NULL values, it does _not_ insert a placeholder in the
  966. * SQL and instead adds an extra ... OR ... IS NULL condition. So we need to skip NULL values here as
  967. * well to create a parameters list that matches the SQL.
  968. */
  969. continue;
  970. }
  972. $sqlParams = array_merge($sqlParams, PersisterHelper::convertToParameterValue($item, $this->em));
  973. $sqlTypes = array_merge($sqlTypes, PersisterHelper::inferParameterTypes($field, $item, $this->class, $this->em));
  974. }
  976. continue;
  977. }
  979. $sqlParams = array_merge($sqlParams, PersisterHelper::convertToParameterValue($value, $this->em));
  980. $sqlTypes = array_merge($sqlTypes, PersisterHelper::inferParameterTypes($field, $value, $this->class, $this->em));
  981. }
  983. return [$sqlParams, $sqlTypes];
  984. }
  986. /**
  987. * {@inheritDoc}
  988. */
  989. public function loadAll(array $criteria = [], ?array $orderBy = null, $limit = null, $offset = null)
  990. {
  991. $this->switchPersisterContext($offset, $limit);
  993. $sql = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  994. [$params, $types] = $this->expandParameters($criteria);
  995. $stmt = $this->conn->executeQuery($sql, $params, $types);
  997. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  999. return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  1000. }
  1002. /**
  1003. * {@inheritDoc}
  1004. */
  1005. public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1006. {
  1007. $this->switchPersisterContext($offset, $limit);
  1009. $stmt = $this->getManyToManyStatement($assoc, $sourceEntity, $offset, $limit);
  1011. return $this->loadArrayFromResult($assoc, $stmt);
  1012. }
  1014. /**
  1015. * Loads an array of entities from a given DBAL statement.
  1016. *
  1017. * @param mixed[] $assoc
  1018. *
  1019. * @return mixed[]
  1020. */
  1021. private function loadArrayFromResult(array $assoc, Result $stmt): array
  1022. {
  1023. $rsm = $this->currentPersisterContext->rsm;
  1024. $hints = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
  1026. if (isset($assoc['indexBy'])) {
  1027. $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  1028. $rsm->addIndexBy('r', $assoc['indexBy']);
  1029. }
  1031. return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  1032. }
  1034. /**
  1035. * Hydrates a collection from a given DBAL statement.
  1036. *
  1037. * @param mixed[] $assoc
  1038. *
  1039. * @return mixed[]
  1040. */
  1041. private function loadCollectionFromStatement(
  1042. array $assoc,
  1043. Result $stmt,
  1044. PersistentCollection $coll
  1045. ): array {
  1046. $rsm = $this->currentPersisterContext->rsm;
  1047. $hints = [
  1048. UnitOfWork::HINT_DEFEREAGERLOAD => true,
  1049. 'collection' => $coll,
  1050. ];
  1052. if (isset($assoc['indexBy'])) {
  1053. $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  1054. $rsm->addIndexBy('r', $assoc['indexBy']);
  1055. }
  1057. return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  1058. }
  1060. /**
  1061. * {@inheritDoc}
  1062. */
  1063. public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1064. {
  1065. $stmt = $this->getManyToManyStatement($assoc, $sourceEntity);
  1067. return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1068. }
  1070. /**
  1071. * @param object $sourceEntity
  1072. * @phpstan-param array<string, mixed> $assoc
  1073. *
  1074. * @return Result
  1075. *
  1076. * @throws MappingException
  1077. */
  1078. private function getManyToManyStatement(
  1079. array $assoc,
  1080. $sourceEntity,
  1081. ?int $offset = null,
  1082. ?int $limit = null
  1083. ) {
  1084. $this->switchPersisterContext($offset, $limit);
  1086. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1087. $class = $sourceClass;
  1088. $association = $assoc;
  1089. $criteria = [];
  1090. $parameters = [];
  1092. if (! $assoc['isOwningSide']) {
  1093. $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1094. $association = $class->associationMappings[$assoc['mappedBy']];
  1095. }
  1097. $joinColumns = $assoc['isOwningSide']
  1098. ? $association['joinTable']['joinColumns']
  1099. : $association['joinTable']['inverseJoinColumns'];
  1101. $quotedJoinTable = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1103. foreach ($joinColumns as $joinColumn) {
  1104. $sourceKeyColumn = $joinColumn['referencedColumnName'];
  1105. $quotedKeyColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1107. switch (true) {
  1108. case $sourceClass->containsForeignIdentifier:
  1109. $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1110. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1112. if (isset($sourceClass->associationMappings[$field])) {
  1113. $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1114. $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1115. }
  1117. break;
  1119. case isset($sourceClass->fieldNames[$sourceKeyColumn]):
  1120. $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1121. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1123. break;
  1125. default:
  1126. throw MappingException::joinColumnMustPointToMappedField(
  1127. $sourceClass->name,
  1128. $sourceKeyColumn
  1129. );
  1130. }
  1132. $criteria[$quotedJoinTable . '.' . $quotedKeyColumn] = $value;
  1133. $parameters[] = [
  1134. 'value' => $value,
  1135. 'field' => $field,
  1136. 'class' => $sourceClass,
  1137. ];
  1138. }
  1140. $sql = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1141. [$params, $types] = $this->expandToManyParameters($parameters);
  1143. return $this->conn->executeQuery($sql, $params, $types);
  1144. }
  1146. /**
  1147. * {@inheritDoc}
  1148. */
  1149. public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, ?array $orderBy = null)
  1150. {
  1151. $this->switchPersisterContext($offset, $limit);
  1153. $lockSql = '';
  1154. $joinSql = '';
  1155. $orderBySql = '';
  1157. if ($assoc !== null && $assoc['type'] === ClassMetadata::MANY_TO_MANY) {
  1158. $joinSql = $this->getSelectManyToManyJoinSQL($assoc);
  1159. }
  1161. if (isset($assoc['orderBy'])) {
  1162. $orderBy = $assoc['orderBy'];
  1163. }
  1165. if ($orderBy) {
  1166. $orderBySql = $this->getOrderBySQL($orderBy, $this->getSQLTableAlias($this->class->name));
  1167. }
  1169. $conditionSql = $criteria instanceof Criteria
  1170. ? $this->getSelectConditionCriteriaSQL($criteria)
  1171. : $this->getSelectConditionSQL($criteria, $assoc);
  1173. switch ($lockMode) {
  1174. case LockMode::PESSIMISTIC_READ:
  1175. $lockSql = ' ' . $this->getReadLockSQL($this->platform);
  1176. break;
  1178. case LockMode::PESSIMISTIC_WRITE:
  1179. $lockSql = ' ' . $this->getWriteLockSQL($this->platform);
  1180. break;
  1181. }
  1183. $columnList = $this->getSelectColumnsSQL();
  1184. $tableAlias = $this->getSQLTableAlias($this->class->name);
  1185. $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1186. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1188. if ($filterSql !== '') {
  1189. $conditionSql = $conditionSql
  1190. ? $conditionSql . ' AND ' . $filterSql
  1191. : $filterSql;
  1192. }
  1194. $select = 'SELECT ' . $columnList;
  1195. $from = ' FROM ' . $tableName . ' ' . $tableAlias;
  1196. $join = $this->currentPersisterContext->selectJoinSql . $joinSql;
  1197. $where = ($conditionSql ? ' WHERE ' . $conditionSql : '');
  1198. $lock = $this->platform->appendLockHint($from, $lockMode ?? LockMode::NONE);
  1199. $query = $select
  1200. . $lock
  1201. . $join
  1202. . $where
  1203. . $orderBySql;
  1205. return $this->platform->modifyLimitQuery($query, $limit, $offset ?? 0) . $lockSql;
  1206. }
  1208. /**
  1209. * {@inheritDoc}
  1210. */
  1211. public function getCountSQL($criteria = [])
  1212. {
  1213. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1214. $tableAlias = $this->getSQLTableAlias($this->class->name);
  1216. $conditionSql = $criteria instanceof Criteria
  1217. ? $this->getSelectConditionCriteriaSQL($criteria)
  1218. : $this->getSelectConditionSQL($criteria);
  1220. $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1222. if ($filterSql !== '') {
  1223. $conditionSql = $conditionSql
  1224. ? $conditionSql . ' AND ' . $filterSql
  1225. : $filterSql;
  1226. }
  1228. return 'SELECT COUNT(*) '
  1229. . 'FROM ' . $tableName . ' ' . $tableAlias
  1230. . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
  1231. }
  1233. /**
  1234. * Gets the ORDER BY SQL snippet for ordered collections.
  1235. *
  1236. * @phpstan-param array<string, string> $orderBy
  1237. *
  1238. * @throws InvalidOrientation
  1239. * @throws InvalidFindByCall
  1240. * @throws UnrecognizedField
  1241. */
  1242. final protected function getOrderBySQL(array $orderBy, string $baseTableAlias): string
  1243. {
  1244. $orderByList = [];
  1246. foreach ($orderBy as $fieldName => $orientation) {
  1247. $orientation = strtoupper(trim($orientation));
  1249. if ($orientation !== 'ASC' && $orientation !== 'DESC') {
  1250. throw InvalidOrientation::fromClassNameAndField($this->class->name, $fieldName);
  1251. }
  1253. if (isset($this->class->fieldMappings[$fieldName])) {
  1254. $tableAlias = isset($this->class->fieldMappings[$fieldName]['inherited'])
  1255. ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
  1256. : $baseTableAlias;
  1258. $columnName = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  1259. $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1261. continue;
  1262. }
  1264. if (isset($this->class->associationMappings[$fieldName])) {
  1265. if (! $this->class->associationMappings[$fieldName]['isOwningSide']) {
  1266. throw InvalidFindByCall::fromInverseSideUsage($this->class->name, $fieldName);
  1267. }
  1269. $tableAlias = isset($this->class->associationMappings[$fieldName]['inherited'])
  1270. ? $this->getSQLTableAlias($this->class->associationMappings[$fieldName]['inherited'])
  1271. : $baseTableAlias;
  1273. foreach ($this->class->associationMappings[$fieldName]['joinColumns'] as $joinColumn) {
  1274. $columnName = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1275. $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1276. }
  1278. continue;
  1279. }
  1281. throw UnrecognizedField::byFullyQualifiedName($this->class->name, $fieldName);
  1282. }
  1284. return ' ORDER BY ' . implode(', ', $orderByList);
  1285. }
  1287. /**
  1288. * Gets the SQL fragment with the list of columns to select when querying for
  1289. * an entity in this persister.
  1290. *
  1291. * Subclasses should override this method to alter or change the select column
  1292. * list SQL fragment. Note that in the implementation of BasicEntityPersister
  1293. * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
  1294. * Subclasses may or may not do the same.
  1295. *
  1296. * @return string The SQL fragment.
  1297. */
  1298. protected function getSelectColumnsSQL()
  1299. {
  1300. if ($this->currentPersisterContext->selectColumnListSql !== null && $this->isFilterHashUpToDate()) {
  1301. return $this->currentPersisterContext->selectColumnListSql;
  1302. }
  1304. $columnList = [];
  1305. $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r'); // r for root
  1307. // Add regular columns to select list
  1308. foreach ($this->class->fieldNames as $field) {
  1309. $columnList[] = $this->getSelectColumnSQL($field, $this->class);
  1310. }
  1312. $this->currentPersisterContext->selectJoinSql = '';
  1313. $eagerAliasCounter = 0;
  1315. foreach ($this->class->associationMappings as $assocField => $assoc) {
  1316. $assocColumnSQL = $this->getSelectColumnAssociationSQL($assocField, $assoc, $this->class);
  1318. if ($assocColumnSQL) {
  1319. $columnList[] = $assocColumnSQL;
  1320. }
  1322. $isAssocToOneInverseSide = $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
  1323. $isAssocFromOneEager = $assoc['type'] & ClassMetadata::TO_ONE && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
  1325. if (! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
  1326. continue;
  1327. }
  1329. if ((($assoc['type'] & ClassMetadata::TO_MANY) > 0) && $this->currentPersisterContext->handlesLimits) {
  1330. continue;
  1331. }
  1333. $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1335. if ($eagerEntity->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  1336. continue; // now this is why you shouldn't use inheritance
  1337. }
  1339. $assocAlias = 'e' . ($eagerAliasCounter++);
  1340. $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc['targetEntity'], $assocAlias, 'r', $assocField);
  1342. foreach ($eagerEntity->fieldNames as $field) {
  1343. $columnList[] = $this->getSelectColumnSQL($field, $eagerEntity, $assocAlias);
  1344. }
  1346. foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
  1347. $eagerAssocColumnSQL = $this->getSelectColumnAssociationSQL(
  1348. $eagerAssocField,
  1349. $eagerAssoc,
  1350. $eagerEntity,
  1351. $assocAlias
  1352. );
  1354. if ($eagerAssocColumnSQL) {
  1355. $columnList[] = $eagerAssocColumnSQL;
  1356. }
  1357. }
  1359. $association = $assoc;
  1360. $joinCondition = [];
  1362. if (isset($assoc['indexBy'])) {
  1363. $this->currentPersisterContext->rsm->addIndexBy($assocAlias, $assoc['indexBy']);
  1364. }
  1366. if (! $assoc['isOwningSide']) {
  1367. $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1368. $association = $eagerEntity->getAssociationMapping($assoc['mappedBy']);
  1369. }
  1371. $joinTableAlias = $this->getSQLTableAlias($eagerEntity->name, $assocAlias);
  1372. $joinTableName = $this->quoteStrategy->getTableName($eagerEntity, $this->platform);
  1374. if ($assoc['isOwningSide']) {
  1375. $tableAlias = $this->getSQLTableAlias($association['targetEntity'], $assocAlias);
  1376. $this->currentPersisterContext->selectJoinSql .= ' ' . $this->getJoinSQLForJoinColumns($association['joinColumns']);
  1378. foreach ($association['joinColumns'] as $joinColumn) {
  1379. $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1380. $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1381. $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'])
  1382. . '.' . $sourceCol . ' = ' . $tableAlias . '.' . $targetCol;
  1383. }
  1385. // Add filter SQL
  1386. $filterSql = $this->generateFilterConditionSQL($eagerEntity, $tableAlias);
  1387. if ($filterSql) {
  1388. $joinCondition[] = $filterSql;
  1389. }
  1390. } else {
  1391. $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
  1393. foreach ($association['joinColumns'] as $joinColumn) {
  1394. $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1395. $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1397. $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'], $assocAlias) . '.' . $sourceCol . ' = '
  1398. . $this->getSQLTableAlias($association['targetEntity']) . '.' . $targetCol;
  1399. }
  1401. // Add filter SQL
  1402. $filterSql = $this->generateFilterConditionSQL($eagerEntity, $joinTableAlias);
  1403. if ($filterSql) {
  1404. $joinCondition[] = $filterSql;
  1405. }
  1406. }
  1408. $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';
  1409. $this->currentPersisterContext->selectJoinSql .= implode(' AND ', $joinCondition);
  1410. }
  1412. $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
  1413. $this->updateFilterHash();
  1415. return $this->currentPersisterContext->selectColumnListSql;
  1416. }
  1418. /**
  1419. * Gets the SQL join fragment used when selecting entities from an association.
  1420. *
  1421. * @param string $field
  1422. * @param AssociationMapping $assoc
  1423. * @param string $alias
  1424. *
  1425. * @return string
  1426. */
  1427. protected function getSelectColumnAssociationSQL($field, $assoc, ClassMetadata $class, $alias = 'r')
  1428. {
  1429. if (! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)) {
  1430. return '';
  1431. }
  1433. $columnList = [];
  1434. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  1435. $isIdentifier = isset($assoc['id']) && $assoc['id'] === true;
  1436. $sqlTableAlias = $this->getSQLTableAlias($class->name, ($alias === 'r' ? '' : $alias));
  1438. foreach ($assoc['joinColumns'] as $joinColumn) {
  1439. $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1440. $resultColumnName = $this->getSQLColumnAlias($joinColumn['name']);
  1441. $type = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  1443. $this->currentPersisterContext->rsm->addMetaResult($alias, $resultColumnName, $joinColumn['name'], $isIdentifier, $type);
  1445. $columnList[] = sprintf('%s.%s AS %s', $sqlTableAlias, $quotedColumn, $resultColumnName);
  1446. }
  1448. return implode(', ', $columnList);
  1449. }
  1451. /**
  1452. * Gets the SQL join fragment used when selecting entities from a
  1453. * many-to-many association.
  1454. *
  1455. * @phpstan-param AssociationMapping $manyToMany
  1456. *
  1457. * @return string
  1458. */
  1459. protected function getSelectManyToManyJoinSQL(array $manyToMany)
  1460. {
  1461. $conditions = [];
  1462. $association = $manyToMany;
  1463. $sourceTableAlias = $this->getSQLTableAlias($this->class->name);
  1465. if (! $manyToMany['isOwningSide']) {
  1466. $targetEntity = $this->em->getClassMetadata($manyToMany['targetEntity']);
  1467. $association = $targetEntity->associationMappings[$manyToMany['mappedBy']];
  1468. }
  1470. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  1471. $joinColumns = $manyToMany['isOwningSide']
  1472. ? $association['joinTable']['inverseJoinColumns']
  1473. : $association['joinTable']['joinColumns'];
  1475. foreach ($joinColumns as $joinColumn) {
  1476. $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1477. $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1478. $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableName . '.' . $quotedSourceColumn;
  1479. }
  1481. return ' INNER JOIN ' . $joinTableName . ' ON ' . implode(' AND ', $conditions);
  1482. }
  1484. /**
  1485. * {@inheritDoc}
  1486. */
  1487. public function getInsertSQL()
  1488. {
  1489. $columns = $this->getInsertColumnList();
  1490. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1492. if ($columns === []) {
  1493. $identityColumn = $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class, $this->platform);
  1495. return $this->platform->getEmptyIdentityInsertSQL($tableName, $identityColumn);
  1496. }
  1498. $placeholders = [];
  1499. $columns = array_unique($columns);
  1501. foreach ($columns as $column) {
  1502. $placeholder = '?';
  1504. if (
  1505. isset($this->class->fieldNames[$column])
  1506. && isset($this->columnTypes[$this->class->fieldNames[$column]])
  1507. && isset($this->class->fieldMappings[$this->class->fieldNames[$column]]['requireSQLConversion'])
  1508. ) {
  1509. $type = Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
  1510. $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  1511. }
  1513. $placeholders[] = $placeholder;
  1514. }
  1516. $columns = implode(', ', $columns);
  1517. $placeholders = implode(', ', $placeholders);
  1519. return sprintf('INSERT INTO %s (%s) VALUES (%s)', $tableName, $columns, $placeholders);
  1520. }
  1522. /**
  1523. * Gets the list of columns to put in the INSERT SQL statement.
  1524. *
  1525. * Subclasses should override this method to alter or change the list of
  1526. * columns placed in the INSERT statements used by the persister.
  1527. *
  1528. * @return string[] The list of columns.
  1529. * @phpstan-return list<string>
  1530. */
  1531. protected function getInsertColumnList()
  1532. {
  1533. $columns = [];
  1535. foreach ($this->class->reflFields as $name => $field) {
  1536. if ($this->class->isVersioned && $this->class->versionField === $name) {
  1537. continue;
  1538. }
  1540. if (isset($this->class->embeddedClasses[$name])) {
  1541. continue;
  1542. }
  1544. if (isset($this->class->associationMappings[$name])) {
  1545. $assoc = $this->class->associationMappings[$name];
  1547. if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  1548. foreach ($assoc['joinColumns'] as $joinColumn) {
  1549. $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1550. }
  1551. }
  1553. continue;
  1554. }
  1556. if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] !== $name) {
  1557. if (isset($this->class->fieldMappings[$name]['notInsertable'])) {
  1558. continue;
  1559. }
  1561. $columns[] = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
  1562. $this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
  1563. }
  1564. }
  1566. return $columns;
  1567. }
  1569. /**
  1570. * Gets the SQL snippet of a qualified column name for the given field name.
  1571. *
  1572. * @param string $field The field name.
  1573. * @param ClassMetadata $class The class that declares this field. The table this class is
  1574. * mapped to must own the column for the given field.
  1575. * @param string $alias
  1576. *
  1577. * @return string
  1578. */
  1579. protected function getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r')
  1580. {
  1581. $root = $alias === 'r' ? '' : $alias;
  1582. $tableAlias = $this->getSQLTableAlias($class->name, $root);
  1583. $fieldMapping = $class->fieldMappings[$field];
  1584. $sql = sprintf('%s.%s', $tableAlias, $this->quoteStrategy->getColumnName($field, $class, $this->platform));
  1586. $columnAlias = null;
  1587. if ($this->currentPersisterContext->rsm->hasColumnAliasByField($alias, $field)) {
  1588. $columnAlias = $this->currentPersisterContext->rsm->getColumnAliasByField($alias, $field);
  1589. }
  1591. if ($columnAlias === null) {
  1592. $columnAlias = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1593. }
  1595. $this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field);
  1596. if (! empty($fieldMapping['enumType'])) {
  1597. $this->currentPersisterContext->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
  1598. }
  1600. if (isset($fieldMapping['requireSQLConversion'])) {
  1601. $type = Type::getType($fieldMapping['type']);
  1602. $sql = $type->convertToPHPValueSQL($sql, $this->platform);
  1603. }
  1605. return $sql . ' AS ' . $columnAlias;
  1606. }
  1608. /**
  1609. * Gets the SQL table alias for the given class name.
  1610. *
  1611. * @param string $className
  1612. * @param string $assocName
  1613. *
  1614. * @return string The SQL table alias.
  1615. *
  1616. * @todo Reconsider. Binding table aliases to class names is not such a good idea.
  1617. */
  1618. protected function getSQLTableAlias($className, $assocName = '')
  1619. {
  1620. if ($assocName) {
  1621. $className .= '#' . $assocName;
  1622. }
  1624. if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
  1625. return $this->currentPersisterContext->sqlTableAliases[$className];
  1626. }
  1628. $tableAlias = 't' . $this->currentPersisterContext->sqlAliasCounter++;
  1630. $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
  1632. return $tableAlias;
  1633. }
  1635. /**
  1636. * {@inheritDoc}
  1637. */
  1638. public function lock(array $criteria, $lockMode)
  1639. {
  1640. $lockSql = '';
  1641. $conditionSql = $this->getSelectConditionSQL($criteria);
  1643. switch ($lockMode) {
  1644. case LockMode::PESSIMISTIC_READ:
  1645. $lockSql = $this->getReadLockSQL($this->platform);
  1647. break;
  1648. case LockMode::PESSIMISTIC_WRITE:
  1649. $lockSql = $this->getWriteLockSQL($this->platform);
  1650. break;
  1651. }
  1653. $lock = $this->getLockTablesSql($lockMode);
  1654. $where = ($conditionSql ? ' WHERE ' . $conditionSql : '') . ' ';
  1655. $sql = 'SELECT 1 '
  1656. . $lock
  1657. . $where
  1658. . $lockSql;
  1660. [$params, $types] = $this->expandParameters($criteria);
  1662. $this->conn->executeQuery($sql, $params, $types);
  1663. }
  1665. /**
  1666. * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
  1667. *
  1668. * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants.
  1669. * @phpstan-param LockMode::*|null $lockMode
  1670. *
  1671. * @return string
  1672. */
  1673. protected function getLockTablesSql($lockMode)
  1674. {
  1675. if ($lockMode === null) {
  1676. Deprecation::trigger(
  1677. 'doctrine/orm',
  1678. 'https://github.com/doctrine/orm/pull/9466',
  1679. 'Passing null as argument to %s is deprecated, pass LockMode::NONE instead.',
  1680. __METHOD__
  1681. );
  1683. $lockMode = LockMode::NONE;
  1684. }
  1686. return $this->platform->appendLockHint(
  1687. 'FROM '
  1688. . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
  1689. . $this->getSQLTableAlias($this->class->name),
  1690. $lockMode
  1691. );
  1692. }
  1694. /**
  1695. * Gets the Select Where Condition from a Criteria object.
  1696. *
  1697. * @return string
  1698. */
  1699. protected function getSelectConditionCriteriaSQL(Criteria $criteria)
  1700. {
  1701. $expression = $criteria->getWhereExpression();
  1703. if ($expression === null) {
  1704. return '';
  1705. }
  1707. $visitor = new SqlExpressionVisitor($this, $this->class);
  1709. return $visitor->dispatch($expression);
  1710. }
  1712. /**
  1713. * {@inheritDoc}
  1714. */
  1715. public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
  1716. {
  1717. $comparison = $comparison ?? (is_array($value) ? Comparison::IN : Comparison::EQ);
  1719. $selectedColumns = [];
  1720. $columns = $this->getSelectConditionStatementColumnSQL($field, $assoc);
  1722. if (count($columns) > 1 && $comparison === Comparison::IN) {
  1723. /*
  1724. * @todo try to support multi-column IN expressions.
  1725. * Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
  1726. */
  1727. throw CantUseInOperatorOnCompositeKeys::create();
  1728. }
  1730. foreach ($columns as $column) {
  1731. $placeholder = '?';
  1733. if (isset($this->class->fieldMappings[$field]['requireSQLConversion'])) {
  1734. $type = Type::getType($this->class->fieldMappings[$field]['type']);
  1735. $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->platform);
  1736. }
  1738. // special case null value handling
  1739. if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && $value === null) {
  1740. $selectedColumns[] = $column . ' IS NULL';
  1742. continue;
  1743. }
  1745. if ($comparison === Comparison::NEQ && $value === null) {
  1746. $selectedColumns[] = $column . ' IS NOT NULL';
  1748. continue;
  1749. }
  1751. if ($comparison === Comparison::IN || $comparison === Comparison::NIN) {
  1752. if (! is_array($value)) {
  1753. $value = [$value];
  1754. }
  1756. if ($value === []) {
  1757. $selectedColumns[] = '1=0';
  1758. continue;
  1759. }
  1761. $nullKeys = array_keys($value, null, true);
  1762. $nonNullValues = array_diff_key($value, array_flip($nullKeys));
  1764. $placeholders = implode(', ', array_fill(0, count($nonNullValues), $placeholder));
  1766. $in = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholders);
  1768. if ($nullKeys) {
  1769. if ($nonNullValues) {
  1770. $selectedColumns[] = sprintf('(%s OR %s IS NULL)', $in, $column);
  1771. } else {
  1772. $selectedColumns[] = $column . ' IS NULL';
  1773. }
  1774. } else {
  1775. $selectedColumns[] = $in;
  1776. }
  1778. continue;
  1779. }
  1781. $selectedColumns[] = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
  1782. }
  1784. return implode(' AND ', $selectedColumns);
  1785. }
  1787. /**
  1788. * Builds the left-hand-side of a where condition statement.
  1789. *
  1790. * @phpstan-param AssociationMapping|null $assoc
  1791. *
  1792. * @return string[]
  1793. * @phpstan-return list<string>
  1794. *
  1795. * @throws InvalidFindByCall
  1796. * @throws UnrecognizedField
  1797. */
  1798. private function getSelectConditionStatementColumnSQL(
  1799. string $field,
  1800. ?array $assoc = null
  1801. ): array {
  1802. if (isset($this->class->fieldMappings[$field])) {
  1803. $className = $this->class->fieldMappings[$field]['inherited'] ?? $this->class->name;
  1805. return [$this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getColumnName($field, $this->class, $this->platform)];
  1806. }
  1808. if (isset($this->class->associationMappings[$field])) {
  1809. $association = $this->class->associationMappings[$field];
  1810. // Many-To-Many requires join table check for joinColumn
  1811. $columns = [];
  1812. $class = $this->class;
  1814. if ($association['type'] === ClassMetadata::MANY_TO_MANY) {
  1815. if (! $association['isOwningSide']) {
  1816. $association = $assoc;
  1817. }
  1819. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1820. $joinColumns = $assoc['isOwningSide']
  1821. ? $association['joinTable']['joinColumns']
  1822. : $association['joinTable']['inverseJoinColumns'];
  1824. foreach ($joinColumns as $joinColumn) {
  1825. $columns[] = $joinTableName . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1826. }
  1827. } else {
  1828. if (! $association['isOwningSide']) {
  1829. throw InvalidFindByCall::fromInverseSideUsage(
  1830. $this->class->name,
  1831. $field
  1832. );
  1833. }
  1835. $className = $association['inherited'] ?? $this->class->name;
  1837. foreach ($association['joinColumns'] as $joinColumn) {
  1838. $columns[] = $this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1839. }
  1840. }
  1842. return $columns;
  1843. }
  1845. if ($assoc !== null && ! str_contains($field, ' ') && ! str_contains($field, '(')) {
  1846. // very careless developers could potentially open up this normally hidden api for userland attacks,
  1847. // therefore checking for spaces and function calls which are not allowed.
  1849. // found a join column condition, not really a "field"
  1850. return [$field];
  1851. }
  1853. throw UnrecognizedField::byFullyQualifiedName($this->class->name, $field);
  1854. }
  1856. /**
  1857. * Gets the conditional SQL fragment used in the WHERE clause when selecting
  1858. * entities in this persister.
  1859. *
  1860. * Subclasses are supposed to override this method if they intend to change
  1861. * or alter the criteria by which entities are selected.
  1862. *
  1863. * @param AssociationMapping|null $assoc
  1864. * @phpstan-param array<string, mixed> $criteria
  1865. * @phpstan-param array<string, mixed>|null $assoc
  1866. *
  1867. * @return string
  1868. */
  1869. protected function getSelectConditionSQL(array $criteria, $assoc = null)
  1870. {
  1871. $conditions = [];
  1873. foreach ($criteria as $field => $value) {
  1874. $conditions[] = $this->getSelectConditionStatementSQL($field, $value, $assoc);
  1875. }
  1877. return implode(' AND ', $conditions);
  1878. }
  1880. /**
  1881. * {@inheritDoc}
  1882. */
  1883. public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1884. {
  1885. $this->switchPersisterContext($offset, $limit);
  1887. $stmt = $this->getOneToManyStatement($assoc, $sourceEntity, $offset, $limit);
  1889. return $this->loadArrayFromResult($assoc, $stmt);
  1890. }
  1892. /**
  1893. * {@inheritDoc}
  1894. */
  1895. public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1896. {
  1897. $stmt = $this->getOneToManyStatement($assoc, $sourceEntity);
  1899. return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1900. }
  1902. /**
  1903. * Builds criteria and execute SQL statement to fetch the one to many entities from.
  1904. *
  1905. * @param object $sourceEntity
  1906. * @phpstan-param AssociationMapping $assoc
  1907. */
  1908. private function getOneToManyStatement(
  1909. array $assoc,
  1910. $sourceEntity,
  1911. ?int $offset = null,
  1912. ?int $limit = null
  1913. ): Result {
  1914. $this->switchPersisterContext($offset, $limit);
  1916. $criteria = [];
  1917. $parameters = [];
  1918. $owningAssoc = $this->class->associationMappings[$assoc['mappedBy']];
  1919. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1920. $tableAlias = $this->getSQLTableAlias($owningAssoc['inherited'] ?? $this->class->name);
  1922. foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  1923. if ($sourceClass->containsForeignIdentifier) {
  1924. $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1925. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1927. if (isset($sourceClass->associationMappings[$field])) {
  1928. $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1929. $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1930. }
  1932. $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1933. $parameters[] = [
  1934. 'value' => $value,
  1935. 'field' => $field,
  1936. 'class' => $sourceClass,
  1937. ];
  1939. continue;
  1940. }
  1942. $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1943. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1945. $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1946. $parameters[] = [
  1947. 'value' => $value,
  1948. 'field' => $field,
  1949. 'class' => $sourceClass,
  1950. ];
  1951. }
  1953. $sql = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1954. [$params, $types] = $this->expandToManyParameters($parameters);
  1956. return $this->conn->executeQuery($sql, $params, $types);
  1957. }
  1959. /**
  1960. * {@inheritDoc}
  1961. */
  1962. public function expandParameters($criteria)
  1963. {
  1964. $params = [];
  1965. $types = [];
  1967. foreach ($criteria as $field => $value) {
  1968. if ($value === null) {
  1969. continue; // skip null values.
  1970. }
  1972. if (is_array($value)) {
  1973. $nonNullValues = array_diff_key($value, array_flip(array_keys($value, null, true)));
  1974. foreach ($nonNullValues as $item) {
  1975. $types = array_merge($types, PersisterHelper::inferParameterTypes($field, $item, $this->class, $this->em));
  1976. $params = array_merge($params, PersisterHelper::convertToParameterValue($item, $this->em));
  1977. }
  1979. continue;
  1980. }
  1982. $types = array_merge($types, PersisterHelper::inferParameterTypes($field, $value, $this->class, $this->em));
  1983. $params = array_merge($params, PersisterHelper::convertToParameterValue($value, $this->em));
  1984. }
  1986. return [$params, $types];
  1987. }
  1989. /**
  1990. * Expands the parameters from the given criteria and use the correct binding types if found,
  1991. * specialized for OneToMany or ManyToMany associations.
  1992. *
  1993. * @param mixed[][] $criteria an array of arrays containing following:
  1994. * - field to which each criterion will be bound
  1995. * - value to be bound
  1996. * - class to which the field belongs to
  1997. *
  1998. * @return mixed[][]
  1999. * @phpstan-return array{0: array, 1: list<int|string|null>}
  2000. */
  2001. private function expandToManyParameters(array $criteria): array
  2002. {
  2003. $params = [];
  2004. $types = [];
  2006. foreach ($criteria as $criterion) {
  2007. if ($criterion['value'] === null) {
  2008. continue; // skip null values.
  2009. }
  2011. $types = array_merge($types, PersisterHelper::inferParameterTypes($criterion['field'], $criterion['value'], $criterion['class'], $this->em));
  2012. $params = array_merge($params, PersisterHelper::convertToParameterValue($criterion['value'], $this->em));
  2013. }
  2015. return [$params, $types];
  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(LockMode::NONE)
  2033. . ' WHERE ' . $this->getSelectConditionSQL($criteria);
  2035. [$params, $types] = $this->expandParameters($criteria);
  2037. if ($extraConditions !== null) {
  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. $filterSql = $this->generateFilterConditionSQL($this->class, $alias);
  2046. if ($filterSql) {
  2047. $sql .= ' AND ' . $filterSql;
  2048. }
  2050. return (bool) $this->conn->fetchOne($sql, $params, $types);
  2051. }
  2053. /**
  2054. * Generates the appropriate join SQL for the given join column.
  2055. *
  2056. * @param array[] $joinColumns The join columns definition of an association.
  2057. * @phpstan-param array<array<string, mixed>> $joinColumns
  2058. *
  2059. * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
  2060. */
  2061. protected function getJoinSQLForJoinColumns($joinColumns)
  2062. {
  2063. // if one of the join columns is nullable, return left join
  2064. foreach ($joinColumns as $joinColumn) {
  2065. if (! isset($joinColumn['nullable']) || $joinColumn['nullable']) {
  2066. return 'LEFT JOIN';
  2067. }
  2068. }
  2070. return 'INNER JOIN';
  2071. }
  2073. /**
  2074. * @param string $columnName
  2075. *
  2076. * @return string
  2077. */
  2078. public function getSQLColumnAlias($columnName)
  2079. {
  2080. return $this->quoteStrategy->getColumnAlias($columnName, $this->currentPersisterContext->sqlAliasCounter++, $this->platform);
  2081. }
  2083. /**
  2084. * Generates the filter SQL for a given entity and table alias.
  2085. *
  2086. * @param ClassMetadata $targetEntity Metadata of the target entity.
  2087. * @param string $targetTableAlias The table alias of the joined/selected table.
  2088. *
  2089. * @return string The SQL query part to add to a query.
  2090. */
  2091. protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
  2092. {
  2093. $filterClauses = [];
  2095. foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  2096. $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  2097. if ($filterExpr !== '') {
  2098. $filterClauses[] = '(' . $filterExpr . ')';
  2099. }
  2100. }
  2102. $sql = implode(' AND ', $filterClauses);
  2104. return $sql ? '(' . $sql . ')' : ''; // Wrap again to avoid "X or Y and FilterConditionSQL"
  2105. }
  2107. /**
  2108. * Switches persister context according to current query offset/limits
  2109. *
  2110. * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
  2111. *
  2112. * @param int|null $offset
  2113. * @param int|null $limit
  2114. *
  2115. * @return void
  2116. */
  2117. protected function switchPersisterContext($offset, $limit)
  2118. {
  2119. if ($offset === null && $limit === null) {
  2120. $this->currentPersisterContext = $this->noLimitsContext;
  2122. return;
  2123. }
  2125. $this->currentPersisterContext = $this->limitsHandlingContext;
  2126. }
  2128. /**
  2129. * @return string[]
  2130. * @phpstan-return list<string>
  2131. */
  2132. protected function getClassIdentifiersTypes(ClassMetadata $class): array
  2133. {
  2134. $entityManager = $this->em;
  2136. return array_map(
  2137. static function ($fieldName) use ($class, $entityManager): string {
  2138. $types = PersisterHelper::getTypeOfField($fieldName, $class, $entityManager);
  2139. assert(isset($types[0]));
  2141. return $types[0];
  2142. },
  2143. $class->identifier
  2144. );
  2145. }
  2146. }