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

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Persisters\Entity;
  7. use BackedEnum;
  8. use Doctrine\Common\Collections\Criteria;
  9. use Doctrine\Common\Collections\Expr\Comparison;
  10. use Doctrine\DBAL\Connection;
  11. use Doctrine\DBAL\LockMode;
  12. use Doctrine\DBAL\Platforms\AbstractPlatform;
  13. use Doctrine\DBAL\Result;
  14. use Doctrine\DBAL\Types\Type;
  15. use Doctrine\DBAL\Types\Types;
  16. use Doctrine\Deprecations\Deprecation;
  17. use Doctrine\ORM\EntityManagerInterface;
  18. use Doctrine\ORM\Internal\CriteriaOrderings;
  19. use Doctrine\ORM\Mapping\ClassMetadata;
  20. use Doctrine\ORM\Mapping\MappingException;
  21. use Doctrine\ORM\Mapping\QuoteStrategy;
  22. use Doctrine\ORM\OptimisticLockException;
  23. use Doctrine\ORM\PersistentCollection;
  24. use Doctrine\ORM\Persisters\Exception\CantUseInOperatorOnCompositeKeys;
  25. use Doctrine\ORM\Persisters\Exception\InvalidOrientation;
  26. use Doctrine\ORM\Persisters\Exception\UnrecognizedField;
  27. use Doctrine\ORM\Persisters\SqlExpressionVisitor;
  28. use Doctrine\ORM\Persisters\SqlValueVisitor;
  29. use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
  30. use Doctrine\ORM\Query;
  31. use Doctrine\ORM\Query\QueryException;
  32. use Doctrine\ORM\Repository\Exception\InvalidFindByCall;
  33. use Doctrine\ORM\UnitOfWork;
  34. use Doctrine\ORM\Utility\IdentifierFlattener;
  35. use Doctrine\ORM\Utility\LockSqlHelper;
  36. use Doctrine\ORM\Utility\PersisterHelper;
  37. use LengthException;
  39. use function array_combine;
  40. use function array_keys;
  41. use function array_map;
  42. use function array_merge;
  43. use function array_search;
  44. use function array_unique;
  45. use function array_values;
  46. use function assert;
  47. use function count;
  48. use function implode;
  49. use function is_array;
  50. use function is_object;
  51. use function reset;
  52. use function spl_object_id;
  53. use function sprintf;
  54. use function str_contains;
  55. use function strtoupper;
  56. use function trim;
  58. /**
  59. * A BasicEntityPersister maps an entity to a single table in a relational database.
  60. *
  61. * A persister is always responsible for a single entity type.
  62. *
  63. * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
  64. * state of entities onto a relational database when the UnitOfWork is committed,
  65. * as well as for basic querying of entities and their associations (not DQL).
  66. *
  67. * The persisting operations that are invoked during a commit of a UnitOfWork to
  68. * persist the persistent entity state are:
  69. *
  70. * - {@link addInsert} : To schedule an entity for insertion.
  71. * - {@link executeInserts} : To execute all scheduled insertions.
  72. * - {@link update} : To update the persistent state of an entity.
  73. * - {@link delete} : To delete the persistent state of an entity.
  74. *
  75. * As can be seen from the above list, insertions are batched and executed all at once
  76. * for increased efficiency.
  77. *
  78. * The querying operations invoked during a UnitOfWork, either through direct find
  79. * requests or lazy-loading, are the following:
  80. *
  81. * - {@link load} : Loads (the state of) a single, managed entity.
  82. * - {@link loadAll} : Loads multiple, managed entities.
  83. * - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
  84. * - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
  85. * - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
  86. *
  87. * The BasicEntityPersister implementation provides the default behavior for
  88. * persisting and querying entities that are mapped to a single database table.
  89. *
  90. * Subclasses can be created to provide custom persisting and querying strategies,
  91. * i.e. spanning multiple tables.
  92. *
  93. * @phpstan-import-type AssociationMapping from ClassMetadata
  94. */
  95. class BasicEntityPersister implements EntityPersister
  96. {
  97. use CriteriaOrderings;
  98. use LockSqlHelper;
  100. /** @var array<string,string> */
  101. private static $comparisonMap = [
  102. Comparison::EQ => '= %s',
  103. Comparison::NEQ => '!= %s',
  104. Comparison::GT => '> %s',
  105. Comparison::GTE => '>= %s',
  106. Comparison::LT => '< %s',
  107. Comparison::LTE => '<= %s',
  108. Comparison::IN => 'IN (%s)',
  109. Comparison::NIN => 'NOT IN (%s)',
  110. Comparison::CONTAINS => 'LIKE %s',
  111. Comparison::STARTS_WITH => 'LIKE %s',
  112. Comparison::ENDS_WITH => 'LIKE %s',
  113. ];
  115. /**
  116. * Metadata object that describes the mapping of the mapped entity class.
  117. *
  118. * @var ClassMetadata
  119. */
  120. protected $class;
  122. /**
  123. * The underlying DBAL Connection of the used EntityManager.
  124. *
  125. * @var Connection $conn
  126. */
  127. protected $conn;
  129. /**
  130. * The database platform.
  131. *
  132. * @var AbstractPlatform
  133. */
  134. protected $platform;
  136. /**
  137. * The EntityManager instance.
  138. *
  139. * @var EntityManagerInterface
  140. */
  141. protected $em;
  143. /**
  144. * Queued inserts.
  145. *
  146. * @phpstan-var array<int, object>
  147. */
  148. protected $queuedInserts = [];
  150. /**
  151. * The map of column names to DBAL mapping types of all prepared columns used
  152. * when INSERTing or UPDATEing an entity.
  153. *
  154. * @see prepareInsertData($entity)
  155. * @see prepareUpdateData($entity)
  156. *
  157. * @var mixed[]
  158. */
  159. protected $columnTypes = [];
  161. /**
  162. * The map of quoted column names.
  163. *
  164. * @see prepareInsertData($entity)
  165. * @see prepareUpdateData($entity)
  166. *
  167. * @var mixed[]
  168. */
  169. protected $quotedColumns = [];
  171. /**
  172. * The quote strategy.
  173. *
  174. * @var QuoteStrategy
  175. */
  176. protected $quoteStrategy;
  178. /**
  179. * The IdentifierFlattener used for manipulating identifiers
  180. *
  181. * @var IdentifierFlattener
  182. */
  183. protected $identifierFlattener;
  185. /** @var CachedPersisterContext */
  186. protected $currentPersisterContext;
  188. /** @var CachedPersisterContext */
  189. private $limitsHandlingContext;
  191. /** @var CachedPersisterContext */
  192. private $noLimitsContext;
  194. /** @var ?string */
  195. private $filterHash = null;
  197. /**
  198. * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
  199. * and persists instances of the class described by the given ClassMetadata descriptor.
  200. */
  201. public function __construct(EntityManagerInterface $em, ClassMetadata $class)
  202. {
  203. $this->em = $em;
  204. $this->class = $class;
  205. $this->conn = $em->getConnection();
  206. $this->platform = $this->conn->getDatabasePlatform();
  207. $this->quoteStrategy = $em->getConfiguration()->getQuoteStrategy();
  208. $this->identifierFlattener = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
  209. $this->noLimitsContext = $this->currentPersisterContext = new CachedPersisterContext(
  210. $class,
  211. new Query\ResultSetMapping(),
  212. false
  213. );
  214. $this->limitsHandlingContext = new CachedPersisterContext(
  215. $class,
  216. new Query\ResultSetMapping(),
  217. true
  218. );
  219. }
  221. final protected function isFilterHashUpToDate(): bool
  222. {
  223. return $this->filterHash === $this->em->getFilters()->getHash();
  224. }
  226. final protected function updateFilterHash(): void
  227. {
  228. $this->filterHash = $this->em->getFilters()->getHash();
  229. }
  231. /**
  232. * {@inheritDoc}
  233. */
  234. public function getClassMetadata()
  235. {
  236. return $this->class;
  237. }
  239. /**
  240. * {@inheritDoc}
  241. */
  242. public function getResultSetMapping()
  243. {
  244. return $this->currentPersisterContext->rsm;
  245. }
  247. /**
  248. * {@inheritDoc}
  249. */
  250. public function addInsert($entity)
  251. {
  252. $this->queuedInserts[spl_object_id($entity)] = $entity;
  253. }
  255. /**
  256. * {@inheritDoc}
  257. */
  258. public function getInserts()
  259. {
  260. return $this->queuedInserts;
  261. }
  263. /**
  264. * {@inheritDoc}
  265. */
  266. public function executeInserts()
  267. {
  268. if (! $this->queuedInserts) {
  269. return;
  270. }
  272. $uow = $this->em->getUnitOfWork();
  273. $idGenerator = $this->class->idGenerator;
  274. $isPostInsertId = $idGenerator->isPostInsertGenerator();
  276. $stmt = $this->conn->prepare($this->getInsertSQL());
  277. $tableName = $this->class->getTableName();
  279. foreach ($this->queuedInserts as $key => $entity) {
  280. $insertData = $this->prepareInsertData($entity);
  282. if (isset($insertData[$tableName])) {
  283. $paramIndex = 1;
  285. foreach ($insertData[$tableName] as $column => $value) {
  286. $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$column]);
  287. }
  288. }
  290. $stmt->executeStatement();
  292. if ($isPostInsertId) {
  293. $generatedId = $idGenerator->generateId($this->em, $entity);
  294. $id = [$this->class->identifier[0] => $generatedId];
  296. $uow->assignPostInsertId($entity, $generatedId);
  297. } else {
  298. $id = $this->class->getIdentifierValues($entity);
  299. }
  301. if ($this->class->requiresFetchAfterChange) {
  302. $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  303. }
  305. // Unset this queued insert, so that the prepareUpdateData() method (called via prepareInsertData() method)
  306. // knows right away (for the next entity already) that the current entity has been written to the database
  307. // and no extra updates need to be scheduled to refer to it.
  308. //
  309. // In \Doctrine\ORM\UnitOfWork::executeInserts(), the UoW already removed entities
  310. // from its own list (\Doctrine\ORM\UnitOfWork::$entityInsertions) right after they
  311. // were given to our addInsert() method.
  312. unset($this->queuedInserts[$key]);
  313. }
  314. }
  316. /**
  317. * Retrieves the default version value which was created
  318. * by the preceding INSERT statement and assigns it back in to the
  319. * entities version field if the given entity is versioned.
  320. * Also retrieves values of columns marked as 'non insertable' and / or
  321. * 'not updatable' and assigns them back to the entities corresponding fields.
  322. *
  323. * @param object $entity
  324. * @param mixed[] $id
  325. *
  326. * @return void
  327. */
  328. protected function assignDefaultVersionAndUpsertableValues($entity, array $id)
  329. {
  330. $values = $this->fetchVersionAndNotUpsertableValues($this->class, $id);
  332. foreach ($values as $field => $value) {
  333. $value = Type::getType($this->class->fieldMappings[$field]['type'])->convertToPHPValue($value, $this->platform);
  335. $this->class->setFieldValue($entity, $field, $value);
  336. }
  337. }
  339. /**
  340. * Fetches the current version value of a versioned entity and / or the values of fields
  341. * marked as 'not insertable' and / or 'not updatable'.
  342. *
  343. * @param ClassMetadata $versionedClass
  344. * @param mixed[] $id
  345. *
  346. * @return mixed
  347. */
  348. protected function fetchVersionAndNotUpsertableValues($versionedClass, array $id)
  349. {
  350. $columnNames = [];
  351. foreach ($this->class->fieldMappings as $key => $column) {
  352. if (isset($column['generated']) || ($this->class->isVersioned && $key === $versionedClass->versionField)) {
  353. $columnNames[$key] = $this->quoteStrategy->getColumnName($key, $versionedClass, $this->platform);
  354. }
  355. }
  357. $tableName = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
  358. $identifier = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
  360. // FIXME: Order with composite keys might not be correct
  361. $sql = 'SELECT ' . implode(', ', $columnNames)
  362. . ' FROM ' . $tableName
  363. . ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
  365. $flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
  367. $values = $this->conn->fetchNumeric(
  368. $sql,
  369. array_values($flatId),
  370. $this->extractIdentifierTypes($id, $versionedClass)
  371. );
  373. if ($values === false) {
  374. throw new LengthException('Unexpected empty result for database query.');
  375. }
  377. $values = array_combine(array_keys($columnNames), $values);
  379. if (! $values) {
  380. throw new LengthException('Unexpected number of database columns.');
  381. }
  383. return $values;
  384. }
  386. /**
  387. * @param mixed[] $id
  388. *
  389. * @return int[]|null[]|string[]
  390. * @phpstan-return list<int|string|null>
  391. */
  392. final protected function extractIdentifierTypes(array $id, ClassMetadata $versionedClass): array
  393. {
  394. $types = [];
  396. foreach ($id as $field => $value) {
  397. $types = array_merge($types, $this->getTypes($field, $value, $versionedClass));
  398. }
  400. return $types;
  401. }
  403. /**
  404. * {@inheritDoc}
  405. */
  406. public function update($entity)
  407. {
  408. $tableName = $this->class->getTableName();
  409. $updateData = $this->prepareUpdateData($entity);
  411. if (! isset($updateData[$tableName])) {
  412. return;
  413. }
  415. $data = $updateData[$tableName];
  417. if (! $data) {
  418. return;
  419. }
  421. $isVersioned = $this->class->isVersioned;
  422. $quotedTableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  424. $this->updateTable($entity, $quotedTableName, $data, $isVersioned);
  426. if ($this->class->requiresFetchAfterChange) {
  427. $id = $this->class->getIdentifierValues($entity);
  429. $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  430. }
  431. }
  433. /**
  434. * Performs an UPDATE statement for an entity on a specific table.
  435. * The UPDATE can optionally be versioned, which requires the entity to have a version field.
  436. *
  437. * @param object $entity The entity object being updated.
  438. * @param string $quotedTableName The quoted name of the table to apply the UPDATE on.
  439. * @param mixed[] $updateData The map of columns to update (column => value).
  440. * @param bool $versioned Whether the UPDATE should be versioned.
  441. *
  442. * @throws UnrecognizedField
  443. * @throws OptimisticLockException
  444. */
  445. final protected function updateTable(
  446. $entity,
  447. $quotedTableName,
  448. array $updateData,
  449. $versioned = false
  450. ): void {
  451. $set = [];
  452. $types = [];
  453. $params = [];
  455. foreach ($updateData as $columnName => $value) {
  456. $placeholder = '?';
  457. $column = $columnName;
  459. switch (true) {
  460. case isset($this->class->fieldNames[$columnName]):
  461. $fieldName = $this->class->fieldNames[$columnName];
  462. $column = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  464. if (isset($this->class->fieldMappings[$fieldName]['requireSQLConversion'])) {
  465. $type = Type::getType($this->columnTypes[$columnName]);
  466. $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  467. }
  469. break;
  471. case isset($this->quotedColumns[$columnName]):
  472. $column = $this->quotedColumns[$columnName];
  474. break;
  475. }
  477. $params[] = $value;
  478. $set[] = $column . ' = ' . $placeholder;
  479. $types[] = $this->columnTypes[$columnName];
  480. }
  482. $where = [];
  483. $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  485. foreach ($this->class->identifier as $idField) {
  486. if (! isset($this->class->associationMappings[$idField])) {
  487. $params[] = $identifier[$idField];
  488. $types[] = $this->class->fieldMappings[$idField]['type'];
  489. $where[] = $this->quoteStrategy->getColumnName($idField, $this->class, $this->platform);
  491. continue;
  492. }
  494. $params[] = $identifier[$idField];
  495. $where[] = $this->quoteStrategy->getJoinColumnName(
  496. $this->class->associationMappings[$idField]['joinColumns'][0],
  497. $this->class,
  498. $this->platform
  499. );
  501. $targetMapping = $this->em->getClassMetadata($this->class->associationMappings[$idField]['targetEntity']);
  502. $targetType = PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping, $this->em);
  504. if ($targetType === []) {
  505. throw UnrecognizedField::byFullyQualifiedName($this->class->name, $targetMapping->identifier[0]);
  506. }
  508. $types[] = reset($targetType);
  509. }
  511. if ($versioned) {
  512. $versionField = $this->class->versionField;
  513. assert($versionField !== null);
  514. $versionFieldType = $this->class->fieldMappings[$versionField]['type'];
  515. $versionColumn = $this->quoteStrategy->getColumnName($versionField, $this->class, $this->platform);
  517. $where[] = $versionColumn;
  518. $types[] = $this->class->fieldMappings[$versionField]['type'];
  519. $params[] = $this->class->reflFields[$versionField]->getValue($entity);
  521. switch ($versionFieldType) {
  522. case Types::SMALLINT:
  523. case Types::INTEGER:
  524. case Types::BIGINT:
  525. $set[] = $versionColumn . ' = ' . $versionColumn . ' + 1';
  526. break;
  528. case Types::DATETIME_MUTABLE:
  529. $set[] = $versionColumn . ' = CURRENT_TIMESTAMP';
  530. break;
  531. }
  532. }
  534. $sql = 'UPDATE ' . $quotedTableName
  535. . ' SET ' . implode(', ', $set)
  536. . ' WHERE ' . implode(' = ? AND ', $where) . ' = ?';
  538. $result = $this->conn->executeStatement($sql, $params, $types);
  540. if ($versioned && ! $result) {
  541. throw OptimisticLockException::lockFailed($entity);
  542. }
  543. }
  545. /**
  546. * @param array<mixed> $identifier
  547. * @param string[] $types
  548. *
  549. * @todo Add check for platform if it supports foreign keys/cascading.
  550. */
  551. protected function deleteJoinTableRecords(array $identifier, array $types): void
  552. {
  553. foreach ($this->class->associationMappings as $mapping) {
  554. if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY || isset($mapping['isOnDeleteCascade'])) {
  555. continue;
  556. }
  558. // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
  559. // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
  560. $selfReferential = ($mapping['targetEntity'] === $mapping['sourceEntity']);
  561. $class = $this->class;
  562. $association = $mapping;
  563. $otherColumns = [];
  564. $otherKeys = [];
  565. $keys = [];
  567. if (! $mapping['isOwningSide']) {
  568. $class = $this->em->getClassMetadata($mapping['targetEntity']);
  569. $association = $class->associationMappings[$mapping['mappedBy']];
  570. }
  572. $joinColumns = $mapping['isOwningSide']
  573. ? $association['joinTable']['joinColumns']
  574. : $association['joinTable']['inverseJoinColumns'];
  576. if ($selfReferential) {
  577. $otherColumns = ! $mapping['isOwningSide']
  578. ? $association['joinTable']['joinColumns']
  579. : $association['joinTable']['inverseJoinColumns'];
  580. }
  582. foreach ($joinColumns as $joinColumn) {
  583. $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  584. }
  586. foreach ($otherColumns as $joinColumn) {
  587. $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  588. }
  590. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  592. $this->conn->delete($joinTableName, array_combine($keys, $identifier), $types);
  594. if ($selfReferential) {
  595. $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier), $types);
  596. }
  597. }
  598. }
  600. /**
  601. * {@inheritDoc}
  602. */
  603. public function delete($entity)
  604. {
  605. $class = $this->class;
  606. $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  607. $tableName = $this->quoteStrategy->getTableName($class, $this->platform);
  608. $idColumns = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform);
  609. $id = array_combine($idColumns, $identifier);
  610. $types = $this->getClassIdentifiersTypes($class);
  612. $this->deleteJoinTableRecords($identifier, $types);
  614. return (bool) $this->conn->delete($tableName, $id, $types);
  615. }
  617. /**
  618. * Prepares the changeset of an entity for database insertion (UPDATE).
  619. *
  620. * The changeset is obtained from the currently running UnitOfWork.
  621. *
  622. * During this preparation the array that is passed as the second parameter is filled with
  623. * <columnName> => <value> pairs, grouped by table name.
  624. *
  625. * Example:
  626. * <code>
  627. * array(
  628. * 'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
  629. * 'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
  630. * ...
  631. * )
  632. * </code>
  633. *
  634. * @param object $entity The entity for which to prepare the data.
  635. * @param bool $isInsert Whether the data to be prepared refers to an insert statement.
  636. *
  637. * @return mixed[][] The prepared data.
  638. * @phpstan-return array<string, array<array-key, mixed|null>>
  639. */
  640. protected function prepareUpdateData($entity, bool $isInsert = false)
  641. {
  642. $versionField = null;
  643. $result = [];
  644. $uow = $this->em->getUnitOfWork();
  646. $versioned = $this->class->isVersioned;
  647. if ($versioned !== false) {
  648. $versionField = $this->class->versionField;
  649. }
  651. foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
  652. if (isset($versionField) && $versionField === $field) {
  653. continue;
  654. }
  656. if (isset($this->class->embeddedClasses[$field])) {
  657. continue;
  658. }
  660. $newVal = $change[1];
  662. if (! isset($this->class->associationMappings[$field])) {
  663. $fieldMapping = $this->class->fieldMappings[$field];
  664. $columnName = $fieldMapping['columnName'];
  666. if (! $isInsert && isset($fieldMapping['notUpdatable'])) {
  667. continue;
  668. }
  670. if ($isInsert && isset($fieldMapping['notInsertable'])) {
  671. continue;
  672. }
  674. $this->columnTypes[$columnName] = $fieldMapping['type'];
  676. $result[$this->getOwningTable($field)][$columnName] = $newVal;
  678. continue;
  679. }
  681. $assoc = $this->class->associationMappings[$field];
  683. // Only owning side of x-1 associations can have a FK column.
  684. if (! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
  685. continue;
  686. }
  688. if ($newVal !== null) {
  689. $oid = spl_object_id($newVal);
  691. // If the associated entity $newVal is not yet persisted and/or does not yet have
  692. // an ID assigned, we must set $newVal = null. This will insert a null value and
  693. // schedule an extra update on the UnitOfWork.
  694. //
  695. // This gives us extra time to a) possibly obtain a database-generated identifier
  696. // value for $newVal, and b) insert $newVal into the database before the foreign
  697. // key reference is being made.
  698. //
  699. // When looking at $this->queuedInserts and $uow->isScheduledForInsert, be aware
  700. // of the implementation details that our own executeInserts() method will remove
  701. // entities from the former as soon as the insert statement has been executed and
  702. // a post-insert ID has been assigned (if necessary), and that the UnitOfWork has
  703. // already removed entities from its own list at the time they were passed to our
  704. // addInsert() method.
  705. //
  706. // Then, there is one extra exception we can make: An entity that references back to itself
  707. // _and_ uses an application-provided ID (the "NONE" generator strategy) also does not
  708. // need the extra update, although it is still in the list of insertions itself.
  709. // This looks like a minor optimization at first, but is the capstone for being able to
  710. // use non-NULLable, self-referencing associations in applications that provide IDs (like UUIDs).
  711. if (
  712. (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal))
  713. && ! ($newVal === $entity && $this->class->isIdentifierNatural())
  714. ) {
  715. $uow->scheduleExtraUpdate($entity, [$field => [null, $newVal]]);
  717. $newVal = null;
  718. }
  719. }
  721. $newValId = null;
  723. if ($newVal !== null) {
  724. $newValId = $uow->getEntityIdentifier($newVal);
  725. }
  727. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  728. $owningTable = $this->getOwningTable($field);
  730. foreach ($assoc['joinColumns'] as $joinColumn) {
  731. $sourceColumn = $joinColumn['name'];
  732. $targetColumn = $joinColumn['referencedColumnName'];
  733. $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  735. $this->quotedColumns[$sourceColumn] = $quotedColumn;
  736. $this->columnTypes[$sourceColumn] = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
  737. $result[$owningTable][$sourceColumn] = $newValId
  738. ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
  739. : null;
  740. }
  741. }
  743. return $result;
  744. }
  746. /**
  747. * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
  748. * The changeset of the entity is obtained from the currently running UnitOfWork.
  749. *
  750. * The default insert data preparation is the same as for updates.
  751. *
  752. * @see prepareUpdateData
  753. *
  754. * @param object $entity The entity for which to prepare the data.
  755. *
  756. * @return mixed[][] The prepared data for the tables to update.
  757. * @phpstan-return array<string, mixed[]>
  758. */
  759. protected function prepareInsertData($entity)
  760. {
  761. return $this->prepareUpdateData($entity, true);
  762. }
  764. /**
  765. * {@inheritDoc}
  766. */
  767. public function getOwningTable($fieldName)
  768. {
  769. return $this->class->getTableName();
  770. }
  772. /**
  773. * {@inheritDoc}
  774. */
  775. public function load(array $criteria, $entity = null, $assoc = null, array $hints = [], $lockMode = null, $limit = null, ?array $orderBy = null)
  776. {
  777. $this->switchPersisterContext(null, $limit);
  779. $sql = $this->getSelectSQL($criteria, $assoc, $lockMode, $limit, null, $orderBy);
  780. [$params, $types] = $this->expandParameters($criteria);
  781. $stmt = $this->conn->executeQuery($sql, $params, $types);
  783. if ($entity !== null) {
  784. $hints[Query::HINT_REFRESH] = true;
  785. $hints[Query::HINT_REFRESH_ENTITY] = $entity;
  786. }
  788. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  789. $entities = $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, $hints);
  791. return $entities ? $entities[0] : null;
  792. }
  794. /**
  795. * {@inheritDoc}
  796. */
  797. public function loadById(array $identifier, $entity = null)
  798. {
  799. return $this->load($identifier, $entity);
  800. }
  802. /**
  803. * {@inheritDoc}
  804. */
  805. public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
  806. {
  807. $foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc['targetEntity']);
  808. if ($foundEntity !== false) {
  809. return $foundEntity;
  810. }
  812. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  814. if ($assoc['isOwningSide']) {
  815. $isInverseSingleValued = $assoc['inversedBy'] && ! $targetClass->isCollectionValuedAssociation($assoc['inversedBy']);
  817. // Mark inverse side as fetched in the hints, otherwise the UoW would
  818. // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
  819. $hints = [];
  821. if ($isInverseSingleValued) {
  822. $hints['fetched']['r'][$assoc['inversedBy']] = true;
  823. }
  825. $targetEntity = $this->load($identifier, null, $assoc, $hints);
  827. // Complete bidirectional association, if necessary
  828. if ($targetEntity !== null && $isInverseSingleValued) {
  829. $targetClass->reflFields[$assoc['inversedBy']]->setValue($targetEntity, $sourceEntity);
  830. }
  832. return $targetEntity;
  833. }
  835. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  836. $owningAssoc = $targetClass->getAssociationMapping($assoc['mappedBy']);
  838. $computedIdentifier = [];
  840. /** @var array<string,mixed>|null $sourceEntityData */
  841. $sourceEntityData = null;
  843. // TRICKY: since the association is specular source and target are flipped
  844. foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  845. if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
  846. // The likely case here is that the column is a join column
  847. // in an association mapping. However, there is no guarantee
  848. // at this point that a corresponding (generally identifying)
  849. // association has been mapped in the source entity. To handle
  850. // this case we directly reference the column-keyed data used
  851. // to initialize the source entity before throwing an exception.
  852. $resolvedSourceData = false;
  853. if (! isset($sourceEntityData)) {
  854. $sourceEntityData = $this->em->getUnitOfWork()->getOriginalEntityData($sourceEntity);
  855. }
  857. if (isset($sourceEntityData[$sourceKeyColumn])) {
  858. $dataValue = $sourceEntityData[$sourceKeyColumn];
  859. if ($dataValue !== null) {
  860. $resolvedSourceData = true;
  861. $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  862. $dataValue;
  863. }
  864. }
  866. if (! $resolvedSourceData) {
  867. throw MappingException::joinColumnMustPointToMappedField(
  868. $sourceClass->name,
  869. $sourceKeyColumn
  870. );
  871. }
  872. } else {
  873. $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  874. $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
  875. }
  876. }
  878. $targetEntity = $this->load($computedIdentifier, null, $assoc);
  880. if ($targetEntity !== null) {
  881. $targetClass->setFieldValue($targetEntity, $assoc['mappedBy'], $sourceEntity);
  882. }
  884. return $targetEntity;
  885. }
  887. /**
  888. * {@inheritDoc}
  889. */
  890. public function refresh(array $id, $entity, $lockMode = null)
  891. {
  892. $sql = $this->getSelectSQL($id, null, $lockMode);
  893. [$params, $types] = $this->expandParameters($id);
  894. $stmt = $this->conn->executeQuery($sql, $params, $types);
  896. $hydrator = $this->em->newHydrator(Query::HYDRATE_OBJECT);
  897. $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
  898. }
  900. /**
  901. * {@inheritDoc}
  902. */
  903. public function count($criteria = [])
  904. {
  905. $sql = $this->getCountSQL($criteria);
  907. [$params, $types] = $criteria instanceof Criteria
  908. ? $this->expandCriteriaParameters($criteria)
  909. : $this->expandParameters($criteria);
  911. return (int) $this->conn->executeQuery($sql, $params, $types)->fetchOne();
  912. }
  914. /**
  915. * {@inheritDoc}
  916. */
  917. public function loadCriteria(Criteria $criteria)
  918. {
  919. $orderBy = self::getCriteriaOrderings($criteria);
  920. $limit = $criteria->getMaxResults();
  921. $offset = $criteria->getFirstResult();
  922. $query = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  924. [$params, $types] = $this->expandCriteriaParameters($criteria);
  926. $stmt = $this->conn->executeQuery($query, $params, $types);
  927. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  929. return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  930. }
  932. /**
  933. * {@inheritDoc}
  934. */
  935. public function expandCriteriaParameters(Criteria $criteria)
  936. {
  937. $expression = $criteria->getWhereExpression();
  938. $sqlParams = [];
  939. $sqlTypes = [];
  941. if ($expression === null) {
  942. return [$sqlParams, $sqlTypes];
  943. }
  945. $valueVisitor = new SqlValueVisitor();
  947. $valueVisitor->dispatch($expression);
  949. [, $types] = $valueVisitor->getParamsAndTypes();
  951. foreach ($types as $type) {
  952. [$field, $value, $operator] = $type;
  954. if ($value === null && ($operator === Comparison::EQ || $operator === Comparison::NEQ)) {
  955. continue;
  956. }
  958. $sqlParams = array_merge($sqlParams, $this->getValues($value));
  959. $sqlTypes = array_merge($sqlTypes, $this->getTypes($field, $value, $this->class));
  960. }
  962. return [$sqlParams, $sqlTypes];
  963. }
  965. /**
  966. * {@inheritDoc}
  967. */
  968. public function loadAll(array $criteria = [], ?array $orderBy = null, $limit = null, $offset = null)
  969. {
  970. $this->switchPersisterContext($offset, $limit);
  972. $sql = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  973. [$params, $types] = $this->expandParameters($criteria);
  974. $stmt = $this->conn->executeQuery($sql, $params, $types);
  976. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  978. return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  979. }
  981. /**
  982. * {@inheritDoc}
  983. */
  984. public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  985. {
  986. $this->switchPersisterContext($offset, $limit);
  988. $stmt = $this->getManyToManyStatement($assoc, $sourceEntity, $offset, $limit);
  990. return $this->loadArrayFromResult($assoc, $stmt);
  991. }
  993. /**
  994. * Loads an array of entities from a given DBAL statement.
  995. *
  996. * @param mixed[] $assoc
  997. *
  998. * @return mixed[]
  999. */
  1000. private function loadArrayFromResult(array $assoc, Result $stmt): array
  1001. {
  1002. $rsm = $this->currentPersisterContext->rsm;
  1003. $hints = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
  1005. if (isset($assoc['indexBy'])) {
  1006. $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  1007. $rsm->addIndexBy('r', $assoc['indexBy']);
  1008. }
  1010. return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  1011. }
  1013. /**
  1014. * Hydrates a collection from a given DBAL statement.
  1015. *
  1016. * @param mixed[] $assoc
  1017. *
  1018. * @return mixed[]
  1019. */
  1020. private function loadCollectionFromStatement(
  1021. array $assoc,
  1022. Result $stmt,
  1023. PersistentCollection $coll
  1024. ): array {
  1025. $rsm = $this->currentPersisterContext->rsm;
  1026. $hints = [
  1027. UnitOfWork::HINT_DEFEREAGERLOAD => true,
  1028. 'collection' => $coll,
  1029. ];
  1031. if (isset($assoc['indexBy'])) {
  1032. $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  1033. $rsm->addIndexBy('r', $assoc['indexBy']);
  1034. }
  1036. return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  1037. }
  1039. /**
  1040. * {@inheritDoc}
  1041. */
  1042. public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1043. {
  1044. $stmt = $this->getManyToManyStatement($assoc, $sourceEntity);
  1046. return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1047. }
  1049. /**
  1050. * @param object $sourceEntity
  1051. * @phpstan-param array<string, mixed> $assoc
  1052. *
  1053. * @return Result
  1054. *
  1055. * @throws MappingException
  1056. */
  1057. private function getManyToManyStatement(
  1058. array $assoc,
  1059. $sourceEntity,
  1060. ?int $offset = null,
  1061. ?int $limit = null
  1062. ) {
  1063. $this->switchPersisterContext($offset, $limit);
  1065. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1066. $class = $sourceClass;
  1067. $association = $assoc;
  1068. $criteria = [];
  1069. $parameters = [];
  1071. if (! $assoc['isOwningSide']) {
  1072. $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1073. $association = $class->associationMappings[$assoc['mappedBy']];
  1074. }
  1076. $joinColumns = $assoc['isOwningSide']
  1077. ? $association['joinTable']['joinColumns']
  1078. : $association['joinTable']['inverseJoinColumns'];
  1080. $quotedJoinTable = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1082. foreach ($joinColumns as $joinColumn) {
  1083. $sourceKeyColumn = $joinColumn['referencedColumnName'];
  1084. $quotedKeyColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1086. switch (true) {
  1087. case $sourceClass->containsForeignIdentifier:
  1088. $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1089. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1091. if (isset($sourceClass->associationMappings[$field])) {
  1092. $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1093. $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1094. }
  1096. break;
  1098. case isset($sourceClass->fieldNames[$sourceKeyColumn]):
  1099. $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1100. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1102. break;
  1104. default:
  1105. throw MappingException::joinColumnMustPointToMappedField(
  1106. $sourceClass->name,
  1107. $sourceKeyColumn
  1108. );
  1109. }
  1111. $criteria[$quotedJoinTable . '.' . $quotedKeyColumn] = $value;
  1112. $parameters[] = [
  1113. 'value' => $value,
  1114. 'field' => $field,
  1115. 'class' => $sourceClass,
  1116. ];
  1117. }
  1119. $sql = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1120. [$params, $types] = $this->expandToManyParameters($parameters);
  1122. return $this->conn->executeQuery($sql, $params, $types);
  1123. }
  1125. /**
  1126. * {@inheritDoc}
  1127. */
  1128. public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, ?array $orderBy = null)
  1129. {
  1130. $this->switchPersisterContext($offset, $limit);
  1132. $lockSql = '';
  1133. $joinSql = '';
  1134. $orderBySql = '';
  1136. if ($assoc !== null && $assoc['type'] === ClassMetadata::MANY_TO_MANY) {
  1137. $joinSql = $this->getSelectManyToManyJoinSQL($assoc);
  1138. }
  1140. if (isset($assoc['orderBy'])) {
  1141. $orderBy = $assoc['orderBy'];
  1142. }
  1144. if ($orderBy) {
  1145. $orderBySql = $this->getOrderBySQL($orderBy, $this->getSQLTableAlias($this->class->name));
  1146. }
  1148. $conditionSql = $criteria instanceof Criteria
  1149. ? $this->getSelectConditionCriteriaSQL($criteria)
  1150. : $this->getSelectConditionSQL($criteria, $assoc);
  1152. switch ($lockMode) {
  1153. case LockMode::PESSIMISTIC_READ:
  1154. $lockSql = ' ' . $this->getReadLockSQL($this->platform);
  1155. break;
  1157. case LockMode::PESSIMISTIC_WRITE:
  1158. $lockSql = ' ' . $this->getWriteLockSQL($this->platform);
  1159. break;
  1160. }
  1162. $columnList = $this->getSelectColumnsSQL();
  1163. $tableAlias = $this->getSQLTableAlias($this->class->name);
  1164. $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1165. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1167. if ($filterSql !== '') {
  1168. $conditionSql = $conditionSql
  1169. ? $conditionSql . ' AND ' . $filterSql
  1170. : $filterSql;
  1171. }
  1173. $select = 'SELECT ' . $columnList;
  1174. $from = ' FROM ' . $tableName . ' ' . $tableAlias;
  1175. $join = $this->currentPersisterContext->selectJoinSql . $joinSql;
  1176. $where = ($conditionSql ? ' WHERE ' . $conditionSql : '');
  1177. $lock = $this->platform->appendLockHint($from, $lockMode ?? LockMode::NONE);
  1178. $query = $select
  1179. . $lock
  1180. . $join
  1181. . $where
  1182. . $orderBySql;
  1184. return $this->platform->modifyLimitQuery($query, $limit, $offset ?? 0) . $lockSql;
  1185. }
  1187. /**
  1188. * {@inheritDoc}
  1189. */
  1190. public function getCountSQL($criteria = [])
  1191. {
  1192. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1193. $tableAlias = $this->getSQLTableAlias($this->class->name);
  1195. $conditionSql = $criteria instanceof Criteria
  1196. ? $this->getSelectConditionCriteriaSQL($criteria)
  1197. : $this->getSelectConditionSQL($criteria);
  1199. $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1201. if ($filterSql !== '') {
  1202. $conditionSql = $conditionSql
  1203. ? $conditionSql . ' AND ' . $filterSql
  1204. : $filterSql;
  1205. }
  1207. return 'SELECT COUNT(*) '
  1208. . 'FROM ' . $tableName . ' ' . $tableAlias
  1209. . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
  1210. }
  1212. /**
  1213. * Gets the ORDER BY SQL snippet for ordered collections.
  1214. *
  1215. * @phpstan-param array<string, string> $orderBy
  1216. *
  1217. * @throws InvalidOrientation
  1218. * @throws InvalidFindByCall
  1219. * @throws UnrecognizedField
  1220. */
  1221. final protected function getOrderBySQL(array $orderBy, string $baseTableAlias): string
  1222. {
  1223. $orderByList = [];
  1225. foreach ($orderBy as $fieldName => $orientation) {
  1226. $orientation = strtoupper(trim($orientation));
  1228. if ($orientation !== 'ASC' && $orientation !== 'DESC') {
  1229. throw InvalidOrientation::fromClassNameAndField($this->class->name, $fieldName);
  1230. }
  1232. if (isset($this->class->fieldMappings[$fieldName])) {
  1233. $tableAlias = isset($this->class->fieldMappings[$fieldName]['inherited'])
  1234. ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
  1235. : $baseTableAlias;
  1237. $columnName = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  1238. $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1240. continue;
  1241. }
  1243. if (isset($this->class->associationMappings[$fieldName])) {
  1244. if (! $this->class->associationMappings[$fieldName]['isOwningSide']) {
  1245. throw InvalidFindByCall::fromInverseSideUsage($this->class->name, $fieldName);
  1246. }
  1248. $tableAlias = isset($this->class->associationMappings[$fieldName]['inherited'])
  1249. ? $this->getSQLTableAlias($this->class->associationMappings[$fieldName]['inherited'])
  1250. : $baseTableAlias;
  1252. foreach ($this->class->associationMappings[$fieldName]['joinColumns'] as $joinColumn) {
  1253. $columnName = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1254. $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1255. }
  1257. continue;
  1258. }
  1260. throw UnrecognizedField::byFullyQualifiedName($this->class->name, $fieldName);
  1261. }
  1263. return ' ORDER BY ' . implode(', ', $orderByList);
  1264. }
  1266. /**
  1267. * Gets the SQL fragment with the list of columns to select when querying for
  1268. * an entity in this persister.
  1269. *
  1270. * Subclasses should override this method to alter or change the select column
  1271. * list SQL fragment. Note that in the implementation of BasicEntityPersister
  1272. * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
  1273. * Subclasses may or may not do the same.
  1274. *
  1275. * @return string The SQL fragment.
  1276. */
  1277. protected function getSelectColumnsSQL()
  1278. {
  1279. if ($this->currentPersisterContext->selectColumnListSql !== null && $this->isFilterHashUpToDate()) {
  1280. return $this->currentPersisterContext->selectColumnListSql;
  1281. }
  1283. $columnList = [];
  1284. $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r'); // r for root
  1286. // Add regular columns to select list
  1287. foreach ($this->class->fieldNames as $field) {
  1288. $columnList[] = $this->getSelectColumnSQL($field, $this->class);
  1289. }
  1291. $this->currentPersisterContext->selectJoinSql = '';
  1292. $eagerAliasCounter = 0;
  1294. foreach ($this->class->associationMappings as $assocField => $assoc) {
  1295. $assocColumnSQL = $this->getSelectColumnAssociationSQL($assocField, $assoc, $this->class);
  1297. if ($assocColumnSQL) {
  1298. $columnList[] = $assocColumnSQL;
  1299. }
  1301. $isAssocToOneInverseSide = $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
  1302. $isAssocFromOneEager = $assoc['type'] & ClassMetadata::TO_ONE && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
  1304. if (! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
  1305. continue;
  1306. }
  1308. if ((($assoc['type'] & ClassMetadata::TO_MANY) > 0) && $this->currentPersisterContext->handlesLimits) {
  1309. continue;
  1310. }
  1312. $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1314. if ($eagerEntity->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  1315. continue; // now this is why you shouldn't use inheritance
  1316. }
  1318. $assocAlias = 'e' . ($eagerAliasCounter++);
  1319. $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc['targetEntity'], $assocAlias, 'r', $assocField);
  1321. foreach ($eagerEntity->fieldNames as $field) {
  1322. $columnList[] = $this->getSelectColumnSQL($field, $eagerEntity, $assocAlias);
  1323. }
  1325. foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
  1326. $eagerAssocColumnSQL = $this->getSelectColumnAssociationSQL(
  1327. $eagerAssocField,
  1328. $eagerAssoc,
  1329. $eagerEntity,
  1330. $assocAlias
  1331. );
  1333. if ($eagerAssocColumnSQL) {
  1334. $columnList[] = $eagerAssocColumnSQL;
  1335. }
  1336. }
  1338. $association = $assoc;
  1339. $joinCondition = [];
  1341. if (isset($assoc['indexBy'])) {
  1342. $this->currentPersisterContext->rsm->addIndexBy($assocAlias, $assoc['indexBy']);
  1343. }
  1345. if (! $assoc['isOwningSide']) {
  1346. $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1347. $association = $eagerEntity->getAssociationMapping($assoc['mappedBy']);
  1348. }
  1350. $joinTableAlias = $this->getSQLTableAlias($eagerEntity->name, $assocAlias);
  1351. $joinTableName = $this->quoteStrategy->getTableName($eagerEntity, $this->platform);
  1353. if ($assoc['isOwningSide']) {
  1354. $tableAlias = $this->getSQLTableAlias($association['targetEntity'], $assocAlias);
  1355. $this->currentPersisterContext->selectJoinSql .= ' ' . $this->getJoinSQLForJoinColumns($association['joinColumns']);
  1357. foreach ($association['joinColumns'] as $joinColumn) {
  1358. $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1359. $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1360. $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'])
  1361. . '.' . $sourceCol . ' = ' . $tableAlias . '.' . $targetCol;
  1362. }
  1364. // Add filter SQL
  1365. $filterSql = $this->generateFilterConditionSQL($eagerEntity, $tableAlias);
  1366. if ($filterSql) {
  1367. $joinCondition[] = $filterSql;
  1368. }
  1369. } else {
  1370. $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
  1372. foreach ($association['joinColumns'] as $joinColumn) {
  1373. $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1374. $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1376. $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'], $assocAlias) . '.' . $sourceCol . ' = '
  1377. . $this->getSQLTableAlias($association['targetEntity']) . '.' . $targetCol;
  1378. }
  1380. // Add filter SQL
  1381. $filterSql = $this->generateFilterConditionSQL($eagerEntity, $joinTableAlias);
  1382. if ($filterSql) {
  1383. $joinCondition[] = $filterSql;
  1384. }
  1385. }
  1387. $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';
  1388. $this->currentPersisterContext->selectJoinSql .= implode(' AND ', $joinCondition);
  1389. }
  1391. $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
  1392. $this->updateFilterHash();
  1394. return $this->currentPersisterContext->selectColumnListSql;
  1395. }
  1397. /**
  1398. * Gets the SQL join fragment used when selecting entities from an association.
  1399. *
  1400. * @param string $field
  1401. * @param AssociationMapping $assoc
  1402. * @param string $alias
  1403. *
  1404. * @return string
  1405. */
  1406. protected function getSelectColumnAssociationSQL($field, $assoc, ClassMetadata $class, $alias = 'r')
  1407. {
  1408. if (! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)) {
  1409. return '';
  1410. }
  1412. $columnList = [];
  1413. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  1414. $isIdentifier = isset($assoc['id']) && $assoc['id'] === true;
  1415. $sqlTableAlias = $this->getSQLTableAlias($class->name, ($alias === 'r' ? '' : $alias));
  1417. foreach ($assoc['joinColumns'] as $joinColumn) {
  1418. $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1419. $resultColumnName = $this->getSQLColumnAlias($joinColumn['name']);
  1420. $type = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  1422. $this->currentPersisterContext->rsm->addMetaResult($alias, $resultColumnName, $joinColumn['name'], $isIdentifier, $type);
  1424. $columnList[] = sprintf('%s.%s AS %s', $sqlTableAlias, $quotedColumn, $resultColumnName);
  1425. }
  1427. return implode(', ', $columnList);
  1428. }
  1430. /**
  1431. * Gets the SQL join fragment used when selecting entities from a
  1432. * many-to-many association.
  1433. *
  1434. * @phpstan-param AssociationMapping $manyToMany
  1435. *
  1436. * @return string
  1437. */
  1438. protected function getSelectManyToManyJoinSQL(array $manyToMany)
  1439. {
  1440. $conditions = [];
  1441. $association = $manyToMany;
  1442. $sourceTableAlias = $this->getSQLTableAlias($this->class->name);
  1444. if (! $manyToMany['isOwningSide']) {
  1445. $targetEntity = $this->em->getClassMetadata($manyToMany['targetEntity']);
  1446. $association = $targetEntity->associationMappings[$manyToMany['mappedBy']];
  1447. }
  1449. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  1450. $joinColumns = $manyToMany['isOwningSide']
  1451. ? $association['joinTable']['inverseJoinColumns']
  1452. : $association['joinTable']['joinColumns'];
  1454. foreach ($joinColumns as $joinColumn) {
  1455. $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1456. $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1457. $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableName . '.' . $quotedSourceColumn;
  1458. }
  1460. return ' INNER JOIN ' . $joinTableName . ' ON ' . implode(' AND ', $conditions);
  1461. }
  1463. /**
  1464. * {@inheritDoc}
  1465. */
  1466. public function getInsertSQL()
  1467. {
  1468. $columns = $this->getInsertColumnList();
  1469. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1471. if ($columns === []) {
  1472. $identityColumn = $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class, $this->platform);
  1474. return $this->platform->getEmptyIdentityInsertSQL($tableName, $identityColumn);
  1475. }
  1477. $placeholders = [];
  1478. $columns = array_unique($columns);
  1480. foreach ($columns as $column) {
  1481. $placeholder = '?';
  1483. if (
  1484. isset($this->class->fieldNames[$column])
  1485. && isset($this->columnTypes[$this->class->fieldNames[$column]])
  1486. && isset($this->class->fieldMappings[$this->class->fieldNames[$column]]['requireSQLConversion'])
  1487. ) {
  1488. $type = Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
  1489. $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  1490. }
  1492. $placeholders[] = $placeholder;
  1493. }
  1495. $columns = implode(', ', $columns);
  1496. $placeholders = implode(', ', $placeholders);
  1498. return sprintf('INSERT INTO %s (%s) VALUES (%s)', $tableName, $columns, $placeholders);
  1499. }
  1501. /**
  1502. * Gets the list of columns to put in the INSERT SQL statement.
  1503. *
  1504. * Subclasses should override this method to alter or change the list of
  1505. * columns placed in the INSERT statements used by the persister.
  1506. *
  1507. * @return string[] The list of columns.
  1508. * @phpstan-return list<string>
  1509. */
  1510. protected function getInsertColumnList()
  1511. {
  1512. $columns = [];
  1514. foreach ($this->class->reflFields as $name => $field) {
  1515. if ($this->class->isVersioned && $this->class->versionField === $name) {
  1516. continue;
  1517. }
  1519. if (isset($this->class->embeddedClasses[$name])) {
  1520. continue;
  1521. }
  1523. if (isset($this->class->associationMappings[$name])) {
  1524. $assoc = $this->class->associationMappings[$name];
  1526. if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  1527. foreach ($assoc['joinColumns'] as $joinColumn) {
  1528. $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1529. }
  1530. }
  1532. continue;
  1533. }
  1535. if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] !== $name) {
  1536. if (isset($this->class->fieldMappings[$name]['notInsertable'])) {
  1537. continue;
  1538. }
  1540. $columns[] = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
  1541. $this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
  1542. }
  1543. }
  1545. return $columns;
  1546. }
  1548. /**
  1549. * Gets the SQL snippet of a qualified column name for the given field name.
  1550. *
  1551. * @param string $field The field name.
  1552. * @param ClassMetadata $class The class that declares this field. The table this class is
  1553. * mapped to must own the column for the given field.
  1554. * @param string $alias
  1555. *
  1556. * @return string
  1557. */
  1558. protected function getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r')
  1559. {
  1560. $root = $alias === 'r' ? '' : $alias;
  1561. $tableAlias = $this->getSQLTableAlias($class->name, $root);
  1562. $fieldMapping = $class->fieldMappings[$field];
  1563. $sql = sprintf('%s.%s', $tableAlias, $this->quoteStrategy->getColumnName($field, $class, $this->platform));
  1565. $columnAlias = null;
  1566. if ($this->currentPersisterContext->rsm->hasColumnAliasByField($alias, $field)) {
  1567. $columnAlias = $this->currentPersisterContext->rsm->getColumnAliasByField($alias, $field);
  1568. }
  1570. if ($columnAlias === null) {
  1571. $columnAlias = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1572. }
  1574. $this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field);
  1575. if (! empty($fieldMapping['enumType'])) {
  1576. $this->currentPersisterContext->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
  1577. }
  1579. if (isset($fieldMapping['requireSQLConversion'])) {
  1580. $type = Type::getType($fieldMapping['type']);
  1581. $sql = $type->convertToPHPValueSQL($sql, $this->platform);
  1582. }
  1584. return $sql . ' AS ' . $columnAlias;
  1585. }
  1587. /**
  1588. * Gets the SQL table alias for the given class name.
  1589. *
  1590. * @param string $className
  1591. * @param string $assocName
  1592. *
  1593. * @return string The SQL table alias.
  1594. *
  1595. * @todo Reconsider. Binding table aliases to class names is not such a good idea.
  1596. */
  1597. protected function getSQLTableAlias($className, $assocName = '')
  1598. {
  1599. if ($assocName) {
  1600. $className .= '#' . $assocName;
  1601. }
  1603. if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
  1604. return $this->currentPersisterContext->sqlTableAliases[$className];
  1605. }
  1607. $tableAlias = 't' . $this->currentPersisterContext->sqlAliasCounter++;
  1609. $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
  1611. return $tableAlias;
  1612. }
  1614. /**
  1615. * {@inheritDoc}
  1616. */
  1617. public function lock(array $criteria, $lockMode)
  1618. {
  1619. $lockSql = '';
  1620. $conditionSql = $this->getSelectConditionSQL($criteria);
  1622. switch ($lockMode) {
  1623. case LockMode::PESSIMISTIC_READ:
  1624. $lockSql = $this->getReadLockSQL($this->platform);
  1626. break;
  1627. case LockMode::PESSIMISTIC_WRITE:
  1628. $lockSql = $this->getWriteLockSQL($this->platform);
  1629. break;
  1630. }
  1632. $lock = $this->getLockTablesSql($lockMode);
  1633. $where = ($conditionSql ? ' WHERE ' . $conditionSql : '') . ' ';
  1634. $sql = 'SELECT 1 '
  1635. . $lock
  1636. . $where
  1637. . $lockSql;
  1639. [$params, $types] = $this->expandParameters($criteria);
  1641. $this->conn->executeQuery($sql, $params, $types);
  1642. }
  1644. /**
  1645. * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
  1646. *
  1647. * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants.
  1648. * @phpstan-param LockMode::*|null $lockMode
  1649. *
  1650. * @return string
  1651. */
  1652. protected function getLockTablesSql($lockMode)
  1653. {
  1654. if ($lockMode === null) {
  1655. Deprecation::trigger(
  1656. 'doctrine/orm',
  1657. 'https://github.com/doctrine/orm/pull/9466',
  1658. 'Passing null as argument to %s is deprecated, pass LockMode::NONE instead.',
  1659. __METHOD__
  1660. );
  1662. $lockMode = LockMode::NONE;
  1663. }
  1665. return $this->platform->appendLockHint(
  1666. 'FROM '
  1667. . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
  1668. . $this->getSQLTableAlias($this->class->name),
  1669. $lockMode
  1670. );
  1671. }
  1673. /**
  1674. * Gets the Select Where Condition from a Criteria object.
  1675. *
  1676. * @return string
  1677. */
  1678. protected function getSelectConditionCriteriaSQL(Criteria $criteria)
  1679. {
  1680. $expression = $criteria->getWhereExpression();
  1682. if ($expression === null) {
  1683. return '';
  1684. }
  1686. $visitor = new SqlExpressionVisitor($this, $this->class);
  1688. return $visitor->dispatch($expression);
  1689. }
  1691. /**
  1692. * {@inheritDoc}
  1693. */
  1694. public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
  1695. {
  1696. $selectedColumns = [];
  1697. $columns = $this->getSelectConditionStatementColumnSQL($field, $assoc);
  1699. if (count($columns) > 1 && $comparison === Comparison::IN) {
  1700. /*
  1701. * @todo try to support multi-column IN expressions.
  1702. * Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
  1703. */
  1704. throw CantUseInOperatorOnCompositeKeys::create();
  1705. }
  1707. foreach ($columns as $column) {
  1708. $placeholder = '?';
  1710. if (isset($this->class->fieldMappings[$field]['requireSQLConversion'])) {
  1711. $type = Type::getType($this->class->fieldMappings[$field]['type']);
  1712. $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->platform);
  1713. }
  1715. if ($comparison !== null) {
  1716. // special case null value handling
  1717. if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && $value === null) {
  1718. $selectedColumns[] = $column . ' IS NULL';
  1720. continue;
  1721. }
  1723. if ($comparison === Comparison::NEQ && $value === null) {
  1724. $selectedColumns[] = $column . ' IS NOT NULL';
  1726. continue;
  1727. }
  1729. $selectedColumns[] = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
  1731. continue;
  1732. }
  1734. if (is_array($value)) {
  1735. $in = sprintf('%s IN (%s)', $column, $placeholder);
  1737. if (array_search(null, $value, true) !== false) {
  1738. $selectedColumns[] = sprintf('(%s OR %s IS NULL)', $in, $column);
  1740. continue;
  1741. }
  1743. $selectedColumns[] = $in;
  1745. continue;
  1746. }
  1748. if ($value === null) {
  1749. $selectedColumns[] = sprintf('%s IS NULL', $column);
  1751. continue;
  1752. }
  1754. $selectedColumns[] = sprintf('%s = %s', $column, $placeholder);
  1755. }
  1757. return implode(' AND ', $selectedColumns);
  1758. }
  1760. /**
  1761. * Builds the left-hand-side of a where condition statement.
  1762. *
  1763. * @phpstan-param AssociationMapping|null $assoc
  1764. *
  1765. * @return string[]
  1766. * @phpstan-return list<string>
  1767. *
  1768. * @throws InvalidFindByCall
  1769. * @throws UnrecognizedField
  1770. */
  1771. private function getSelectConditionStatementColumnSQL(
  1772. string $field,
  1773. ?array $assoc = null
  1774. ): array {
  1775. if (isset($this->class->fieldMappings[$field])) {
  1776. $className = $this->class->fieldMappings[$field]['inherited'] ?? $this->class->name;
  1778. return [$this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getColumnName($field, $this->class, $this->platform)];
  1779. }
  1781. if (isset($this->class->associationMappings[$field])) {
  1782. $association = $this->class->associationMappings[$field];
  1783. // Many-To-Many requires join table check for joinColumn
  1784. $columns = [];
  1785. $class = $this->class;
  1787. if ($association['type'] === ClassMetadata::MANY_TO_MANY) {
  1788. if (! $association['isOwningSide']) {
  1789. $association = $assoc;
  1790. }
  1792. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1793. $joinColumns = $assoc['isOwningSide']
  1794. ? $association['joinTable']['joinColumns']
  1795. : $association['joinTable']['inverseJoinColumns'];
  1797. foreach ($joinColumns as $joinColumn) {
  1798. $columns[] = $joinTableName . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1799. }
  1800. } else {
  1801. if (! $association['isOwningSide']) {
  1802. throw InvalidFindByCall::fromInverseSideUsage(
  1803. $this->class->name,
  1804. $field
  1805. );
  1806. }
  1808. $className = $association['inherited'] ?? $this->class->name;
  1810. foreach ($association['joinColumns'] as $joinColumn) {
  1811. $columns[] = $this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1812. }
  1813. }
  1815. return $columns;
  1816. }
  1818. if ($assoc !== null && ! str_contains($field, ' ') && ! str_contains($field, '(')) {
  1819. // very careless developers could potentially open up this normally hidden api for userland attacks,
  1820. // therefore checking for spaces and function calls which are not allowed.
  1822. // found a join column condition, not really a "field"
  1823. return [$field];
  1824. }
  1826. throw UnrecognizedField::byFullyQualifiedName($this->class->name, $field);
  1827. }
  1829. /**
  1830. * Gets the conditional SQL fragment used in the WHERE clause when selecting
  1831. * entities in this persister.
  1832. *
  1833. * Subclasses are supposed to override this method if they intend to change
  1834. * or alter the criteria by which entities are selected.
  1835. *
  1836. * @param AssociationMapping|null $assoc
  1837. * @phpstan-param array<string, mixed> $criteria
  1838. * @phpstan-param array<string, mixed>|null $assoc
  1839. *
  1840. * @return string
  1841. */
  1842. protected function getSelectConditionSQL(array $criteria, $assoc = null)
  1843. {
  1844. $conditions = [];
  1846. foreach ($criteria as $field => $value) {
  1847. $conditions[] = $this->getSelectConditionStatementSQL($field, $value, $assoc);
  1848. }
  1850. return implode(' AND ', $conditions);
  1851. }
  1853. /**
  1854. * {@inheritDoc}
  1855. */
  1856. public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1857. {
  1858. $this->switchPersisterContext($offset, $limit);
  1860. $stmt = $this->getOneToManyStatement($assoc, $sourceEntity, $offset, $limit);
  1862. return $this->loadArrayFromResult($assoc, $stmt);
  1863. }
  1865. /**
  1866. * {@inheritDoc}
  1867. */
  1868. public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1869. {
  1870. $stmt = $this->getOneToManyStatement($assoc, $sourceEntity);
  1872. return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1873. }
  1875. /**
  1876. * Builds criteria and execute SQL statement to fetch the one to many entities from.
  1877. *
  1878. * @param object $sourceEntity
  1879. * @phpstan-param AssociationMapping $assoc
  1880. */
  1881. private function getOneToManyStatement(
  1882. array $assoc,
  1883. $sourceEntity,
  1884. ?int $offset = null,
  1885. ?int $limit = null
  1886. ): Result {
  1887. $this->switchPersisterContext($offset, $limit);
  1889. $criteria = [];
  1890. $parameters = [];
  1891. $owningAssoc = $this->class->associationMappings[$assoc['mappedBy']];
  1892. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1893. $tableAlias = $this->getSQLTableAlias($owningAssoc['inherited'] ?? $this->class->name);
  1895. foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  1896. if ($sourceClass->containsForeignIdentifier) {
  1897. $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1898. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1900. if (isset($sourceClass->associationMappings[$field])) {
  1901. $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1902. $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1903. }
  1905. $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1906. $parameters[] = [
  1907. 'value' => $value,
  1908. 'field' => $field,
  1909. 'class' => $sourceClass,
  1910. ];
  1912. continue;
  1913. }
  1915. $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1916. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1918. $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1919. $parameters[] = [
  1920. 'value' => $value,
  1921. 'field' => $field,
  1922. 'class' => $sourceClass,
  1923. ];
  1924. }
  1926. $sql = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1927. [$params, $types] = $this->expandToManyParameters($parameters);
  1929. return $this->conn->executeQuery($sql, $params, $types);
  1930. }
  1932. /**
  1933. * {@inheritDoc}
  1934. */
  1935. public function expandParameters($criteria)
  1936. {
  1937. $params = [];
  1938. $types = [];
  1940. foreach ($criteria as $field => $value) {
  1941. if ($value === null) {
  1942. continue; // skip null values.
  1943. }
  1945. $types = array_merge($types, $this->getTypes($field, $value, $this->class));
  1946. $params = array_merge($params, $this->getValues($value));
  1947. }
  1949. return [$params, $types];
  1950. }
  1952. /**
  1953. * Expands the parameters from the given criteria and use the correct binding types if found,
  1954. * specialized for OneToMany or ManyToMany associations.
  1955. *
  1956. * @param mixed[][] $criteria an array of arrays containing following:
  1957. * - field to which each criterion will be bound
  1958. * - value to be bound
  1959. * - class to which the field belongs to
  1960. *
  1961. * @return mixed[][]
  1962. * @phpstan-return array{0: array, 1: list<int|string|null>}
  1963. */
  1964. private function expandToManyParameters(array $criteria): array
  1965. {
  1966. $params = [];
  1967. $types = [];
  1969. foreach ($criteria as $criterion) {
  1970. if ($criterion['value'] === null) {
  1971. continue; // skip null values.
  1972. }
  1974. $types = array_merge($types, $this->getTypes($criterion['field'], $criterion['value'], $criterion['class']));
  1975. $params = array_merge($params, $this->getValues($criterion['value']));
  1976. }
  1978. return [$params, $types];
  1979. }
  1981. /**
  1982. * Infers field types to be used by parameter type casting.
  1983. *
  1984. * @param mixed $value
  1985. *
  1986. * @return int[]|null[]|string[]
  1987. * @phpstan-return list<int|string|null>
  1988. *
  1989. * @throws QueryException
  1990. */
  1991. private function getTypes(string $field, $value, ClassMetadata $class): array
  1992. {
  1993. $types = [];
  1995. switch (true) {
  1996. case isset($class->fieldMappings[$field]):
  1997. $types = array_merge($types, [$class->fieldMappings[$field]['type']]);
  1998. break;
  2000. case isset($class->associationMappings[$field]):
  2001. $assoc = $class->associationMappings[$field];
  2002. $class = $this->em->getClassMetadata($assoc['targetEntity']);
  2004. if (! $assoc['isOwningSide']) {
  2005. $assoc = $class->associationMappings[$assoc['mappedBy']];
  2006. $class = $this->em->getClassMetadata($assoc['targetEntity']);
  2007. }
  2009. $columns = $assoc['type'] === ClassMetadata::MANY_TO_MANY
  2010. ? $assoc['relationToTargetKeyColumns']
  2011. : $assoc['sourceToTargetKeyColumns'];
  2013. foreach ($columns as $column) {
  2014. $types[] = PersisterHelper::getTypeOfColumn($column, $class, $this->em);
  2015. }
  2017. break;
  2019. default:
  2020. $types[] = null;
  2021. break;
  2022. }
  2024. if (is_array($value)) {
  2025. return array_map(static function ($type) {
  2026. $type = Type::getType($type);
  2028. return $type->getBindingType() + Connection::ARRAY_PARAM_OFFSET;
  2029. }, $types);
  2030. }
  2032. return $types;
  2033. }
  2035. /**
  2036. * Retrieves the parameters that identifies a value.
  2037. *
  2038. * @param mixed $value
  2039. *
  2040. * @return mixed[]
  2041. */
  2042. private function getValues($value): array
  2043. {
  2044. if (is_array($value)) {
  2045. $newValue = [];
  2047. foreach ($value as $itemValue) {
  2048. $newValue = array_merge($newValue, $this->getValues($itemValue));
  2049. }
  2051. return [$newValue];
  2052. }
  2054. return $this->getIndividualValue($value);
  2055. }
  2057. /**
  2058. * Retrieves an individual parameter value.
  2059. *
  2060. * @param mixed $value
  2061. *
  2062. * @phpstan-return list<mixed>
  2063. */
  2064. private function getIndividualValue($value): array
  2065. {
  2066. if (! is_object($value)) {
  2067. return [$value];
  2068. }
  2070. if ($value instanceof BackedEnum) {
  2071. return [$value->value];
  2072. }
  2074. $valueClass = DefaultProxyClassNameResolver::getClass($value);
  2076. if ($this->em->getMetadataFactory()->isTransient($valueClass)) {
  2077. return [$value];
  2078. }
  2080. $class = $this->em->getClassMetadata($valueClass);
  2082. if ($class->isIdentifierComposite) {
  2083. $newValue = [];
  2085. foreach ($class->getIdentifierValues($value) as $innerValue) {
  2086. $newValue = array_merge($newValue, $this->getValues($innerValue));
  2087. }
  2089. return $newValue;
  2090. }
  2092. return [$this->em->getUnitOfWork()->getSingleIdentifierValue($value)];
  2093. }
  2095. /**
  2096. * {@inheritDoc}
  2097. */
  2098. public function exists($entity, ?Criteria $extraConditions = null)
  2099. {
  2100. $criteria = $this->class->getIdentifierValues($entity);
  2102. if (! $criteria) {
  2103. return false;
  2104. }
  2106. $alias = $this->getSQLTableAlias($this->class->name);
  2108. $sql = 'SELECT 1 '
  2109. . $this->getLockTablesSql(LockMode::NONE)
  2110. . ' WHERE ' . $this->getSelectConditionSQL($criteria);
  2112. [$params, $types] = $this->expandParameters($criteria);
  2114. if ($extraConditions !== null) {
  2115. $sql .= ' AND ' . $this->getSelectConditionCriteriaSQL($extraConditions);
  2116. [$criteriaParams, $criteriaTypes] = $this->expandCriteriaParameters($extraConditions);
  2118. $params = array_merge($params, $criteriaParams);
  2119. $types = array_merge($types, $criteriaTypes);
  2120. }
  2122. $filterSql = $this->generateFilterConditionSQL($this->class, $alias);
  2123. if ($filterSql) {
  2124. $sql .= ' AND ' . $filterSql;
  2125. }
  2127. return (bool) $this->conn->fetchOne($sql, $params, $types);
  2128. }
  2130. /**
  2131. * Generates the appropriate join SQL for the given join column.
  2132. *
  2133. * @param array[] $joinColumns The join columns definition of an association.
  2134. * @phpstan-param array<array<string, mixed>> $joinColumns
  2135. *
  2136. * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
  2137. */
  2138. protected function getJoinSQLForJoinColumns($joinColumns)
  2139. {
  2140. // if one of the join columns is nullable, return left join
  2141. foreach ($joinColumns as $joinColumn) {
  2142. if (! isset($joinColumn['nullable']) || $joinColumn['nullable']) {
  2143. return 'LEFT JOIN';
  2144. }
  2145. }
  2147. return 'INNER JOIN';
  2148. }
  2150. /**
  2151. * @param string $columnName
  2152. *
  2153. * @return string
  2154. */
  2155. public function getSQLColumnAlias($columnName)
  2156. {
  2157. return $this->quoteStrategy->getColumnAlias($columnName, $this->currentPersisterContext->sqlAliasCounter++, $this->platform);
  2158. }
  2160. /**
  2161. * Generates the filter SQL for a given entity and table alias.
  2162. *
  2163. * @param ClassMetadata $targetEntity Metadata of the target entity.
  2164. * @param string $targetTableAlias The table alias of the joined/selected table.
  2165. *
  2166. * @return string The SQL query part to add to a query.
  2167. */
  2168. protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
  2169. {
  2170. $filterClauses = [];
  2172. foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  2173. $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  2174. if ($filterExpr !== '') {
  2175. $filterClauses[] = '(' . $filterExpr . ')';
  2176. }
  2177. }
  2179. $sql = implode(' AND ', $filterClauses);
  2181. return $sql ? '(' . $sql . ')' : ''; // Wrap again to avoid "X or Y and FilterConditionSQL"
  2182. }
  2184. /**
  2185. * Switches persister context according to current query offset/limits
  2186. *
  2187. * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
  2188. *
  2189. * @param int|null $offset
  2190. * @param int|null $limit
  2191. *
  2192. * @return void
  2193. */
  2194. protected function switchPersisterContext($offset, $limit)
  2195. {
  2196. if ($offset === null && $limit === null) {
  2197. $this->currentPersisterContext = $this->noLimitsContext;
  2199. return;
  2200. }
  2202. $this->currentPersisterContext = $this->limitsHandlingContext;
  2203. }
  2205. /**
  2206. * @return string[]
  2207. * @phpstan-return list<string>
  2208. */
  2209. protected function getClassIdentifiersTypes(ClassMetadata $class): array
  2210. {
  2211. $entityManager = $this->em;
  2213. return array_map(
  2214. static function ($fieldName) use ($class, $entityManager): string {
  2215. $types = PersisterHelper::getTypeOfField($fieldName, $class, $entityManager);
  2216. assert(isset($types[0]));
  2218. return $types[0];
  2219. },
  2220. $class->identifier
  2221. );
  2222. }
  2223. }