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

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\Common\Util\ClassUtils;
  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\ORM\EntityManagerInterface;
  17. use Doctrine\ORM\Mapping\ClassMetadata;
  18. use Doctrine\ORM\Mapping\MappingException;
  19. use Doctrine\ORM\Mapping\QuoteStrategy;
  20. use Doctrine\ORM\OptimisticLockException;
  21. use Doctrine\ORM\PersistentCollection;
  22. use Doctrine\ORM\Persisters\Exception\CantUseInOperatorOnCompositeKeys;
  23. use Doctrine\ORM\Persisters\Exception\InvalidOrientation;
  24. use Doctrine\ORM\Persisters\Exception\UnrecognizedField;
  25. use Doctrine\ORM\Persisters\SqlExpressionVisitor;
  26. use Doctrine\ORM\Persisters\SqlValueVisitor;
  27. use Doctrine\ORM\Query;
  28. use Doctrine\ORM\Query\QueryException;
  29. use Doctrine\ORM\Repository\Exception\InvalidFindByCall;
  30. use Doctrine\ORM\UnitOfWork;
  31. use Doctrine\ORM\Utility\IdentifierFlattener;
  32. use Doctrine\ORM\Utility\PersisterHelper;
  33. use LengthException;
  35. use function array_combine;
  36. use function array_keys;
  37. use function array_map;
  38. use function array_merge;
  39. use function array_search;
  40. use function array_unique;
  41. use function array_values;
  42. use function assert;
  43. use function count;
  44. use function implode;
  45. use function is_array;
  46. use function is_object;
  47. use function reset;
  48. use function spl_object_id;
  49. use function sprintf;
  50. use function strpos;
  51. use function strtoupper;
  52. use function trim;
  54. /**
  55. * A BasicEntityPersister maps an entity to a single table in a relational database.
  56. *
  57. * A persister is always responsible for a single entity type.
  58. *
  59. * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
  60. * state of entities onto a relational database when the UnitOfWork is committed,
  61. * as well as for basic querying of entities and their associations (not DQL).
  62. *
  63. * The persisting operations that are invoked during a commit of a UnitOfWork to
  64. * persist the persistent entity state are:
  65. *
  66. * - {@link addInsert} : To schedule an entity for insertion.
  67. * - {@link executeInserts} : To execute all scheduled insertions.
  68. * - {@link update} : To update the persistent state of an entity.
  69. * - {@link delete} : To delete the persistent state of an entity.
  70. *
  71. * As can be seen from the above list, insertions are batched and executed all at once
  72. * for increased efficiency.
  73. *
  74. * The querying operations invoked during a UnitOfWork, either through direct find
  75. * requests or lazy-loading, are the following:
  76. *
  77. * - {@link load} : Loads (the state of) a single, managed entity.
  78. * - {@link loadAll} : Loads multiple, managed entities.
  79. * - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
  80. * - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
  81. * - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
  82. *
  83. * The BasicEntityPersister implementation provides the default behavior for
  84. * persisting and querying entities that are mapped to a single database table.
  85. *
  86. * Subclasses can be created to provide custom persisting and querying strategies,
  87. * i.e. spanning multiple tables.
  88. */
  89. class BasicEntityPersister implements EntityPersister
  90. {
  91. /** @var array<string,string> */
  92. private static $comparisonMap = [
  93. Comparison::EQ => '= %s',
  94. Comparison::NEQ => '!= %s',
  95. Comparison::GT => '> %s',
  96. Comparison::GTE => '>= %s',
  97. Comparison::LT => '< %s',
  98. Comparison::LTE => '<= %s',
  99. Comparison::IN => 'IN (%s)',
  100. Comparison::NIN => 'NOT IN (%s)',
  101. Comparison::CONTAINS => 'LIKE %s',
  102. Comparison::STARTS_WITH => 'LIKE %s',
  103. Comparison::ENDS_WITH => 'LIKE %s',
  104. ];
  106. /**
  107. * Metadata object that describes the mapping of the mapped entity class.
  108. *
  109. * @var ClassMetadata
  110. */
  111. protected $class;
  113. /**
  114. * The underlying DBAL Connection of the used EntityManager.
  115. *
  116. * @var Connection $conn
  117. */
  118. protected $conn;
  120. /**
  121. * The database platform.
  122. *
  123. * @var AbstractPlatform
  124. */
  125. protected $platform;
  127. /**
  128. * The EntityManager instance.
  129. *
  130. * @var EntityManagerInterface
  131. */
  132. protected $em;
  134. /**
  135. * Queued inserts.
  136. *
  137. * @psalm-var array<int, object>
  138. */
  139. protected $queuedInserts = [];
  141. /**
  142. * The map of column names to DBAL mapping types of all prepared columns used
  143. * when INSERTing or UPDATEing an entity.
  144. *
  145. * @see prepareInsertData($entity)
  146. * @see prepareUpdateData($entity)
  147. *
  148. * @var mixed[]
  149. */
  150. protected $columnTypes = [];
  152. /**
  153. * The map of quoted column names.
  154. *
  155. * @see prepareInsertData($entity)
  156. * @see prepareUpdateData($entity)
  157. *
  158. * @var mixed[]
  159. */
  160. protected $quotedColumns = [];
  162. /**
  163. * The INSERT SQL statement used for entities handled by this persister.
  164. * This SQL is only generated once per request, if at all.
  165. *
  166. * @var string
  167. */
  168. private $insertSql;
  170. /**
  171. * The quote strategy.
  172. *
  173. * @var QuoteStrategy
  174. */
  175. protected $quoteStrategy;
  177. /**
  178. * The IdentifierFlattener used for manipulating identifiers
  179. *
  180. * @var IdentifierFlattener
  181. */
  182. private $identifierFlattener;
  184. /** @var CachedPersisterContext */
  185. protected $currentPersisterContext;
  187. /** @var CachedPersisterContext */
  188. private $limitsHandlingContext;
  190. /** @var CachedPersisterContext */
  191. private $noLimitsContext;
  193. /**
  194. * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
  195. * and persists instances of the class described by the given ClassMetadata descriptor.
  196. */
  197. public function __construct(EntityManagerInterface $em, ClassMetadata $class)
  198. {
  199. $this->em = $em;
  200. $this->class = $class;
  201. $this->conn = $em->getConnection();
  202. $this->platform = $this->conn->getDatabasePlatform();
  203. $this->quoteStrategy = $em->getConfiguration()->getQuoteStrategy();
  204. $this->identifierFlattener = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
  205. $this->noLimitsContext = $this->currentPersisterContext = new CachedPersisterContext(
  206. $class,
  207. new Query\ResultSetMapping(),
  208. false
  209. );
  210. $this->limitsHandlingContext = new CachedPersisterContext(
  211. $class,
  212. new Query\ResultSetMapping(),
  213. true
  214. );
  215. }
  217. /**
  218. * {@inheritdoc}
  219. */
  220. public function getClassMetadata()
  221. {
  222. return $this->class;
  223. }
  225. /**
  226. * {@inheritdoc}
  227. */
  228. public function getResultSetMapping()
  229. {
  230. return $this->currentPersisterContext->rsm;
  231. }
  233. /**
  234. * {@inheritdoc}
  235. */
  236. public function addInsert($entity)
  237. {
  238. $this->queuedInserts[spl_object_id($entity)] = $entity;
  239. }
  241. /**
  242. * {@inheritdoc}
  243. */
  244. public function getInserts()
  245. {
  246. return $this->queuedInserts;
  247. }
  249. /**
  250. * {@inheritdoc}
  251. */
  252. public function executeInserts()
  253. {
  254. if (! $this->queuedInserts) {
  255. return [];
  256. }
  258. $postInsertIds = [];
  259. $idGenerator = $this->class->idGenerator;
  260. $isPostInsertId = $idGenerator->isPostInsertGenerator();
  262. $stmt = $this->conn->prepare($this->getInsertSQL());
  263. $tableName = $this->class->getTableName();
  265. foreach ($this->queuedInserts as $entity) {
  266. $insertData = $this->prepareInsertData($entity);
  268. if (isset($insertData[$tableName])) {
  269. $paramIndex = 1;
  271. foreach ($insertData[$tableName] as $column => $value) {
  272. $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$column]);
  273. }
  274. }
  276. $stmt->executeStatement();
  278. if ($isPostInsertId) {
  279. $generatedId = $idGenerator->generateId($this->em, $entity);
  280. $id = [$this->class->identifier[0] => $generatedId];
  281. $postInsertIds[] = [
  282. 'generatedId' => $generatedId,
  283. 'entity' => $entity,
  284. ];
  285. } else {
  286. $id = $this->class->getIdentifierValues($entity);
  287. }
  289. if ($this->class->requiresFetchAfterChange) {
  290. $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  291. }
  292. }
  294. $this->queuedInserts = [];
  296. return $postInsertIds;
  297. }
  299. /**
  300. * Retrieves the default version value which was created
  301. * by the preceding INSERT statement and assigns it back in to the
  302. * entities version field if the given entity is versioned.
  303. * Also retrieves values of columns marked as 'non insertable' and / or
  304. * 'not updatable' and assigns them back to the entities corresponding fields.
  305. *
  306. * @param object $entity
  307. * @param mixed[] $id
  308. *
  309. * @return void
  310. */
  311. protected function assignDefaultVersionAndUpsertableValues($entity, array $id)
  312. {
  313. $values = $this->fetchVersionAndNotUpsertableValues($this->class, $id);
  315. foreach ($values as $field => $value) {
  316. $value = Type::getType($this->class->fieldMappings[$field]['type'])->convertToPHPValue($value, $this->platform);
  318. $this->class->setFieldValue($entity, $field, $value);
  319. }
  320. }
  322. /**
  323. * Fetches the current version value of a versioned entity and / or the values of fields
  324. * marked as 'not insertable' and / or 'not updatable'.
  325. *
  326. * @param ClassMetadata $versionedClass
  327. * @param mixed[] $id
  328. *
  329. * @return mixed
  330. */
  331. protected function fetchVersionAndNotUpsertableValues($versionedClass, array $id)
  332. {
  333. $columnNames = [];
  334. foreach ($this->class->fieldMappings as $key => $column) {
  335. if (isset($column['generated']) || ($this->class->isVersioned && $key === $versionedClass->versionField)) {
  336. $columnNames[$key] = $this->quoteStrategy->getColumnName($key, $versionedClass, $this->platform);
  337. }
  338. }
  340. $tableName = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
  341. $identifier = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
  343. // FIXME: Order with composite keys might not be correct
  344. $sql = 'SELECT ' . implode(', ', $columnNames)
  345. . ' FROM ' . $tableName
  346. . ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
  348. $flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
  350. $values = $this->conn->fetchNumeric(
  351. $sql,
  352. array_values($flatId),
  353. $this->extractIdentifierTypes($id, $versionedClass)
  354. );
  356. if ($values === false) {
  357. throw new LengthException('Unexpected empty result for database query.');
  358. }
  360. $values = array_combine(array_keys($columnNames), $values);
  362. if (! $values) {
  363. throw new LengthException('Unexpected number of database columns.');
  364. }
  366. return $values;
  367. }
  369. /**
  370. * @param mixed[] $id
  371. *
  372. * @return int[]|null[]|string[]
  373. * @psalm-return list<int|string|null>
  374. */
  375. private function extractIdentifierTypes(array $id, ClassMetadata $versionedClass): array
  376. {
  377. $types = [];
  379. foreach ($id as $field => $value) {
  380. $types = array_merge($types, $this->getTypes($field, $value, $versionedClass));
  381. }
  383. return $types;
  384. }
  386. /**
  387. * {@inheritdoc}
  388. */
  389. public function update($entity)
  390. {
  391. $tableName = $this->class->getTableName();
  392. $updateData = $this->prepareUpdateData($entity);
  394. if (! isset($updateData[$tableName])) {
  395. return;
  396. }
  398. $data = $updateData[$tableName];
  400. if (! $data) {
  401. return;
  402. }
  404. $isVersioned = $this->class->isVersioned;
  405. $quotedTableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  407. $this->updateTable($entity, $quotedTableName, $data, $isVersioned);
  409. if ($this->class->requiresFetchAfterChange) {
  410. $id = $this->class->getIdentifierValues($entity);
  412. $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  413. }
  414. }
  416. /**
  417. * Performs an UPDATE statement for an entity on a specific table.
  418. * The UPDATE can optionally be versioned, which requires the entity to have a version field.
  419. *
  420. * @param object $entity The entity object being updated.
  421. * @param string $quotedTableName The quoted name of the table to apply the UPDATE on.
  422. * @param mixed[] $updateData The map of columns to update (column => value).
  423. * @param bool $versioned Whether the UPDATE should be versioned.
  424. *
  425. * @throws UnrecognizedField
  426. * @throws OptimisticLockException
  427. */
  428. final protected function updateTable(
  429. $entity,
  430. $quotedTableName,
  431. array $updateData,
  432. $versioned = false
  433. ): void {
  434. $set = [];
  435. $types = [];
  436. $params = [];
  438. foreach ($updateData as $columnName => $value) {
  439. $placeholder = '?';
  440. $column = $columnName;
  442. switch (true) {
  443. case isset($this->class->fieldNames[$columnName]):
  444. $fieldName = $this->class->fieldNames[$columnName];
  445. $column = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  447. if (isset($this->class->fieldMappings[$fieldName]['requireSQLConversion'])) {
  448. $type = Type::getType($this->columnTypes[$columnName]);
  449. $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  450. }
  452. break;
  454. case isset($this->quotedColumns[$columnName]):
  455. $column = $this->quotedColumns[$columnName];
  457. break;
  458. }
  460. $params[] = $value;
  461. $set[] = $column . ' = ' . $placeholder;
  462. $types[] = $this->columnTypes[$columnName];
  463. }
  465. $where = [];
  466. $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  468. foreach ($this->class->identifier as $idField) {
  469. if (! isset($this->class->associationMappings[$idField])) {
  470. $params[] = $identifier[$idField];
  471. $types[] = $this->class->fieldMappings[$idField]['type'];
  472. $where[] = $this->quoteStrategy->getColumnName($idField, $this->class, $this->platform);
  474. continue;
  475. }
  477. $params[] = $identifier[$idField];
  478. $where[] = $this->quoteStrategy->getJoinColumnName(
  479. $this->class->associationMappings[$idField]['joinColumns'][0],
  480. $this->class,
  481. $this->platform
  482. );
  484. $targetMapping = $this->em->getClassMetadata($this->class->associationMappings[$idField]['targetEntity']);
  485. $targetType = PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping, $this->em);
  487. if ($targetType === []) {
  488. throw UnrecognizedField::byName($targetMapping->identifier[0]);
  489. }
  491. $types[] = reset($targetType);
  492. }
  494. if ($versioned) {
  495. $versionField = $this->class->versionField;
  496. $versionFieldType = $this->class->fieldMappings[$versionField]['type'];
  497. $versionColumn = $this->quoteStrategy->getColumnName($versionField, $this->class, $this->platform);
  499. $where[] = $versionColumn;
  500. $types[] = $this->class->fieldMappings[$versionField]['type'];
  501. $params[] = $this->class->reflFields[$versionField]->getValue($entity);
  503. switch ($versionFieldType) {
  504. case Types::SMALLINT:
  505. case Types::INTEGER:
  506. case Types::BIGINT:
  507. $set[] = $versionColumn . ' = ' . $versionColumn . ' + 1';
  508. break;
  510. case Types::DATETIME_MUTABLE:
  511. $set[] = $versionColumn . ' = CURRENT_TIMESTAMP';
  512. break;
  513. }
  514. }
  516. $sql = 'UPDATE ' . $quotedTableName
  517. . ' SET ' . implode(', ', $set)
  518. . ' WHERE ' . implode(' = ? AND ', $where) . ' = ?';
  520. $result = $this->conn->executeStatement($sql, $params, $types);
  522. if ($versioned && ! $result) {
  523. throw OptimisticLockException::lockFailed($entity);
  524. }
  525. }
  527. /**
  528. * @param array<mixed> $identifier
  529. * @param string[] $types
  530. *
  531. * @todo Add check for platform if it supports foreign keys/cascading.
  532. */
  533. protected function deleteJoinTableRecords(array $identifier, array $types): void
  534. {
  535. foreach ($this->class->associationMappings as $mapping) {
  536. if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY) {
  537. continue;
  538. }
  540. // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
  541. // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
  542. $selfReferential = ($mapping['targetEntity'] === $mapping['sourceEntity']);
  543. $class = $this->class;
  544. $association = $mapping;
  545. $otherColumns = [];
  546. $otherKeys = [];
  547. $keys = [];
  549. if (! $mapping['isOwningSide']) {
  550. $class = $this->em->getClassMetadata($mapping['targetEntity']);
  551. $association = $class->associationMappings[$mapping['mappedBy']];
  552. }
  554. $joinColumns = $mapping['isOwningSide']
  555. ? $association['joinTable']['joinColumns']
  556. : $association['joinTable']['inverseJoinColumns'];
  558. if ($selfReferential) {
  559. $otherColumns = ! $mapping['isOwningSide']
  560. ? $association['joinTable']['joinColumns']
  561. : $association['joinTable']['inverseJoinColumns'];
  562. }
  564. foreach ($joinColumns as $joinColumn) {
  565. $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  566. }
  568. foreach ($otherColumns as $joinColumn) {
  569. $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  570. }
  572. if (isset($mapping['isOnDeleteCascade'])) {
  573. continue;
  574. }
  576. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  578. $this->conn->delete($joinTableName, array_combine($keys, $identifier), $types);
  580. if ($selfReferential) {
  581. $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier), $types);
  582. }
  583. }
  584. }
  586. /**
  587. * {@inheritdoc}
  588. */
  589. public function delete($entity)
  590. {
  591. $class = $this->class;
  592. $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  593. $tableName = $this->quoteStrategy->getTableName($class, $this->platform);
  594. $idColumns = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform);
  595. $id = array_combine($idColumns, $identifier);
  596. $types = $this->getClassIdentifiersTypes($class);
  598. $this->deleteJoinTableRecords($identifier, $types);
  600. return (bool) $this->conn->delete($tableName, $id, $types);
  601. }
  603. /**
  604. * Prepares the changeset of an entity for database insertion (UPDATE).
  605. *
  606. * The changeset is obtained from the currently running UnitOfWork.
  607. *
  608. * During this preparation the array that is passed as the second parameter is filled with
  609. * <columnName> => <value> pairs, grouped by table name.
  610. *
  611. * Example:
  612. * <code>
  613. * array(
  614. * 'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
  615. * 'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
  616. * ...
  617. * )
  618. * </code>
  619. *
  620. * @param object $entity The entity for which to prepare the data.
  621. * @param bool $isInsert Whether the data to be prepared refers to an insert statement.
  622. *
  623. * @return mixed[][] The prepared data.
  624. * @psalm-return array<string, array<array-key, mixed|null>>
  625. */
  626. protected function prepareUpdateData($entity, bool $isInsert = false)
  627. {
  628. $versionField = null;
  629. $result = [];
  630. $uow = $this->em->getUnitOfWork();
  632. $versioned = $this->class->isVersioned;
  633. if ($versioned !== false) {
  634. $versionField = $this->class->versionField;
  635. }
  637. foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
  638. if (isset($versionField) && $versionField === $field) {
  639. continue;
  640. }
  642. if (isset($this->class->embeddedClasses[$field])) {
  643. continue;
  644. }
  646. $newVal = $change[1];
  648. if (! isset($this->class->associationMappings[$field])) {
  649. $fieldMapping = $this->class->fieldMappings[$field];
  650. $columnName = $fieldMapping['columnName'];
  652. if (! $isInsert && isset($fieldMapping['notUpdatable'])) {
  653. continue;
  654. }
  656. if ($isInsert && isset($fieldMapping['notInsertable'])) {
  657. continue;
  658. }
  660. $this->columnTypes[$columnName] = $fieldMapping['type'];
  662. $result[$this->getOwningTable($field)][$columnName] = $newVal;
  664. continue;
  665. }
  667. $assoc = $this->class->associationMappings[$field];
  669. // Only owning side of x-1 associations can have a FK column.
  670. if (! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
  671. continue;
  672. }
  674. if ($newVal !== null) {
  675. $oid = spl_object_id($newVal);
  677. if (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal)) {
  678. // The associated entity $newVal is not yet persisted, so we must
  679. // set $newVal = null, in order to insert a null value and schedule an
  680. // extra update on the UnitOfWork.
  681. $uow->scheduleExtraUpdate($entity, [$field => [null, $newVal]]);
  683. $newVal = null;
  684. }
  685. }
  687. $newValId = null;
  689. if ($newVal !== null) {
  690. $newValId = $uow->getEntityIdentifier($newVal);
  691. }
  693. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  694. $owningTable = $this->getOwningTable($field);
  696. foreach ($assoc['joinColumns'] as $joinColumn) {
  697. $sourceColumn = $joinColumn['name'];
  698. $targetColumn = $joinColumn['referencedColumnName'];
  699. $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  701. $this->quotedColumns[$sourceColumn] = $quotedColumn;
  702. $this->columnTypes[$sourceColumn] = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
  703. $result[$owningTable][$sourceColumn] = $newValId
  704. ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
  705. : null;
  706. }
  707. }
  709. return $result;
  710. }
  712. /**
  713. * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
  714. * The changeset of the entity is obtained from the currently running UnitOfWork.
  715. *
  716. * The default insert data preparation is the same as for updates.
  717. *
  718. * @see prepareUpdateData
  719. *
  720. * @param object $entity The entity for which to prepare the data.
  721. *
  722. * @return mixed[][] The prepared data for the tables to update.
  723. * @psalm-return array<string, mixed[]>
  724. */
  725. protected function prepareInsertData($entity)
  726. {
  727. return $this->prepareUpdateData($entity, true);
  728. }
  730. /**
  731. * {@inheritdoc}
  732. */
  733. public function getOwningTable($fieldName)
  734. {
  735. return $this->class->getTableName();
  736. }
  738. /**
  739. * {@inheritdoc}
  740. */
  741. public function load(array $criteria, $entity = null, $assoc = null, array $hints = [], $lockMode = null, $limit = null, ?array $orderBy = null)
  742. {
  743. $this->switchPersisterContext(null, $limit);
  745. $sql = $this->getSelectSQL($criteria, $assoc, $lockMode, $limit, null, $orderBy);
  746. [$params, $types] = $this->expandParameters($criteria);
  747. $stmt = $this->conn->executeQuery($sql, $params, $types);
  749. if ($entity !== null) {
  750. $hints[Query::HINT_REFRESH] = true;
  751. $hints[Query::HINT_REFRESH_ENTITY] = $entity;
  752. }
  754. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  755. $entities = $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, $hints);
  757. return $entities ? $entities[0] : null;
  758. }
  760. /**
  761. * {@inheritdoc}
  762. */
  763. public function loadById(array $identifier, $entity = null)
  764. {
  765. return $this->load($identifier, $entity);
  766. }
  768. /**
  769. * {@inheritdoc}
  770. */
  771. public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
  772. {
  773. $foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc['targetEntity']);
  774. if ($foundEntity !== false) {
  775. return $foundEntity;
  776. }
  778. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  780. if ($assoc['isOwningSide']) {
  781. $isInverseSingleValued = $assoc['inversedBy'] && ! $targetClass->isCollectionValuedAssociation($assoc['inversedBy']);
  783. // Mark inverse side as fetched in the hints, otherwise the UoW would
  784. // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
  785. $hints = [];
  787. if ($isInverseSingleValued) {
  788. $hints['fetched']['r'][$assoc['inversedBy']] = true;
  789. }
  791. $targetEntity = $this->load($identifier, null, $assoc, $hints);
  793. // Complete bidirectional association, if necessary
  794. if ($targetEntity !== null && $isInverseSingleValued) {
  795. $targetClass->reflFields[$assoc['inversedBy']]->setValue($targetEntity, $sourceEntity);
  796. }
  798. return $targetEntity;
  799. }
  801. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  802. $owningAssoc = $targetClass->getAssociationMapping($assoc['mappedBy']);
  804. $computedIdentifier = [];
  806. // TRICKY: since the association is specular source and target are flipped
  807. foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  808. if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
  809. throw MappingException::joinColumnMustPointToMappedField(
  810. $sourceClass->name,
  811. $sourceKeyColumn
  812. );
  813. }
  815. $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  816. $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
  817. }
  819. $targetEntity = $this->load($computedIdentifier, null, $assoc);
  821. if ($targetEntity !== null) {
  822. $targetClass->setFieldValue($targetEntity, $assoc['mappedBy'], $sourceEntity);
  823. }
  825. return $targetEntity;
  826. }
  828. /**
  829. * {@inheritdoc}
  830. */
  831. public function refresh(array $id, $entity, $lockMode = null)
  832. {
  833. $sql = $this->getSelectSQL($id, null, $lockMode);
  834. [$params, $types] = $this->expandParameters($id);
  835. $stmt = $this->conn->executeQuery($sql, $params, $types);
  837. $hydrator = $this->em->newHydrator(Query::HYDRATE_OBJECT);
  838. $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
  839. }
  841. /**
  842. * {@inheritDoc}
  843. */
  844. public function count($criteria = [])
  845. {
  846. $sql = $this->getCountSQL($criteria);
  848. [$params, $types] = $criteria instanceof Criteria
  849. ? $this->expandCriteriaParameters($criteria)
  850. : $this->expandParameters($criteria);
  852. return (int) $this->conn->executeQuery($sql, $params, $types)->fetchOne();
  853. }
  855. /**
  856. * {@inheritdoc}
  857. */
  858. public function loadCriteria(Criteria $criteria)
  859. {
  860. $orderBy = $criteria->getOrderings();
  861. $limit = $criteria->getMaxResults();
  862. $offset = $criteria->getFirstResult();
  863. $query = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  865. [$params, $types] = $this->expandCriteriaParameters($criteria);
  867. $stmt = $this->conn->executeQuery($query, $params, $types);
  868. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  870. return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  871. }
  873. /**
  874. * {@inheritdoc}
  875. */
  876. public function expandCriteriaParameters(Criteria $criteria)
  877. {
  878. $expression = $criteria->getWhereExpression();
  879. $sqlParams = [];
  880. $sqlTypes = [];
  882. if ($expression === null) {
  883. return [$sqlParams, $sqlTypes];
  884. }
  886. $valueVisitor = new SqlValueVisitor();
  888. $valueVisitor->dispatch($expression);
  890. [$params, $types] = $valueVisitor->getParamsAndTypes();
  892. foreach ($params as $param) {
  893. $sqlParams = array_merge($sqlParams, $this->getValues($param));
  894. }
  896. foreach ($types as $type) {
  897. [$field, $value] = $type;
  898. $sqlTypes = array_merge($sqlTypes, $this->getTypes($field, $value, $this->class));
  899. }
  901. return [$sqlParams, $sqlTypes];
  902. }
  904. /**
  905. * {@inheritdoc}
  906. */
  907. public function loadAll(array $criteria = [], ?array $orderBy = null, $limit = null, $offset = null)
  908. {
  909. $this->switchPersisterContext($offset, $limit);
  911. $sql = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  912. [$params, $types] = $this->expandParameters($criteria);
  913. $stmt = $this->conn->executeQuery($sql, $params, $types);
  915. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  917. return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  918. }
  920. /**
  921. * {@inheritdoc}
  922. */
  923. public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  924. {
  925. $this->switchPersisterContext($offset, $limit);
  927. $stmt = $this->getManyToManyStatement($assoc, $sourceEntity, $offset, $limit);
  929. return $this->loadArrayFromResult($assoc, $stmt);
  930. }
  932. /**
  933. * Loads an array of entities from a given DBAL statement.
  934. *
  935. * @param mixed[] $assoc
  936. *
  937. * @return mixed[]
  938. */
  939. private function loadArrayFromResult(array $assoc, Result $stmt): array
  940. {
  941. $rsm = $this->currentPersisterContext->rsm;
  942. $hints = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
  944. if (isset($assoc['indexBy'])) {
  945. $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  946. $rsm->addIndexBy('r', $assoc['indexBy']);
  947. }
  949. return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  950. }
  952. /**
  953. * Hydrates a collection from a given DBAL statement.
  954. *
  955. * @param mixed[] $assoc
  956. *
  957. * @return mixed[]
  958. */
  959. private function loadCollectionFromStatement(
  960. array $assoc,
  961. Result $stmt,
  962. PersistentCollection $coll
  963. ): array {
  964. $rsm = $this->currentPersisterContext->rsm;
  965. $hints = [
  966. UnitOfWork::HINT_DEFEREAGERLOAD => true,
  967. 'collection' => $coll,
  968. ];
  970. if (isset($assoc['indexBy'])) {
  971. $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  972. $rsm->addIndexBy('r', $assoc['indexBy']);
  973. }
  975. return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  976. }
  978. /**
  979. * {@inheritdoc}
  980. */
  981. public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  982. {
  983. $stmt = $this->getManyToManyStatement($assoc, $sourceEntity);
  985. return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  986. }
  988. /**
  989. * @param object $sourceEntity
  990. * @psalm-param array<string, mixed> $assoc
  991. *
  992. * @return Result
  993. *
  994. * @throws MappingException
  995. */
  996. private function getManyToManyStatement(
  997. array $assoc,
  998. $sourceEntity,
  999. ?int $offset = null,
  1000. ?int $limit = null
  1001. ) {
  1002. $this->switchPersisterContext($offset, $limit);
  1004. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1005. $class = $sourceClass;
  1006. $association = $assoc;
  1007. $criteria = [];
  1008. $parameters = [];
  1010. if (! $assoc['isOwningSide']) {
  1011. $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1012. $association = $class->associationMappings[$assoc['mappedBy']];
  1013. }
  1015. $joinColumns = $assoc['isOwningSide']
  1016. ? $association['joinTable']['joinColumns']
  1017. : $association['joinTable']['inverseJoinColumns'];
  1019. $quotedJoinTable = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1021. foreach ($joinColumns as $joinColumn) {
  1022. $sourceKeyColumn = $joinColumn['referencedColumnName'];
  1023. $quotedKeyColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1025. switch (true) {
  1026. case $sourceClass->containsForeignIdentifier:
  1027. $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1028. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1030. if (isset($sourceClass->associationMappings[$field])) {
  1031. $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1032. $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1033. }
  1035. break;
  1037. case isset($sourceClass->fieldNames[$sourceKeyColumn]):
  1038. $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1039. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1041. break;
  1043. default:
  1044. throw MappingException::joinColumnMustPointToMappedField(
  1045. $sourceClass->name,
  1046. $sourceKeyColumn
  1047. );
  1048. }
  1050. $criteria[$quotedJoinTable . '.' . $quotedKeyColumn] = $value;
  1051. $parameters[] = [
  1052. 'value' => $value,
  1053. 'field' => $field,
  1054. 'class' => $sourceClass,
  1055. ];
  1056. }
  1058. $sql = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1059. [$params, $types] = $this->expandToManyParameters($parameters);
  1061. return $this->conn->executeQuery($sql, $params, $types);
  1062. }
  1064. /**
  1065. * {@inheritdoc}
  1066. */
  1067. public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, ?array $orderBy = null)
  1068. {
  1069. $this->switchPersisterContext($offset, $limit);
  1071. $lockSql = '';
  1072. $joinSql = '';
  1073. $orderBySql = '';
  1075. if ($assoc !== null && $assoc['type'] === ClassMetadata::MANY_TO_MANY) {
  1076. $joinSql = $this->getSelectManyToManyJoinSQL($assoc);
  1077. }
  1079. if (isset($assoc['orderBy'])) {
  1080. $orderBy = $assoc['orderBy'];
  1081. }
  1083. if ($orderBy) {
  1084. $orderBySql = $this->getOrderBySQL($orderBy, $this->getSQLTableAlias($this->class->name));
  1085. }
  1087. $conditionSql = $criteria instanceof Criteria
  1088. ? $this->getSelectConditionCriteriaSQL($criteria)
  1089. : $this->getSelectConditionSQL($criteria, $assoc);
  1091. switch ($lockMode) {
  1092. case LockMode::PESSIMISTIC_READ:
  1093. $lockSql = ' ' . $this->platform->getReadLockSQL();
  1094. break;
  1096. case LockMode::PESSIMISTIC_WRITE:
  1097. $lockSql = ' ' . $this->platform->getWriteLockSQL();
  1098. break;
  1099. }
  1101. $columnList = $this->getSelectColumnsSQL();
  1102. $tableAlias = $this->getSQLTableAlias($this->class->name);
  1103. $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1104. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1106. if ($filterSql !== '') {
  1107. $conditionSql = $conditionSql
  1108. ? $conditionSql . ' AND ' . $filterSql
  1109. : $filterSql;
  1110. }
  1112. $select = 'SELECT ' . $columnList;
  1113. $from = ' FROM ' . $tableName . ' ' . $tableAlias;
  1114. $join = $this->currentPersisterContext->selectJoinSql . $joinSql;
  1115. $where = ($conditionSql ? ' WHERE ' . $conditionSql : '');
  1116. $lock = $this->platform->appendLockHint($from, $lockMode ?? LockMode::NONE);
  1117. $query = $select
  1118. . $lock
  1119. . $join
  1120. . $where
  1121. . $orderBySql;
  1123. return $this->platform->modifyLimitQuery($query, $limit, $offset ?? 0) . $lockSql;
  1124. }
  1126. /**
  1127. * {@inheritDoc}
  1128. */
  1129. public function getCountSQL($criteria = [])
  1130. {
  1131. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1132. $tableAlias = $this->getSQLTableAlias($this->class->name);
  1134. $conditionSql = $criteria instanceof Criteria
  1135. ? $this->getSelectConditionCriteriaSQL($criteria)
  1136. : $this->getSelectConditionSQL($criteria);
  1138. $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1140. if ($filterSql !== '') {
  1141. $conditionSql = $conditionSql
  1142. ? $conditionSql . ' AND ' . $filterSql
  1143. : $filterSql;
  1144. }
  1146. return 'SELECT COUNT(*) '
  1147. . 'FROM ' . $tableName . ' ' . $tableAlias
  1148. . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
  1149. }
  1151. /**
  1152. * Gets the ORDER BY SQL snippet for ordered collections.
  1153. *
  1154. * @psalm-param array<string, string> $orderBy
  1155. *
  1156. * @throws InvalidOrientation
  1157. * @throws InvalidFindByCall
  1158. * @throws UnrecognizedField
  1159. */
  1160. final protected function getOrderBySQL(array $orderBy, string $baseTableAlias): string
  1161. {
  1162. $orderByList = [];
  1164. foreach ($orderBy as $fieldName => $orientation) {
  1165. $orientation = strtoupper(trim($orientation));
  1167. if ($orientation !== 'ASC' && $orientation !== 'DESC') {
  1168. throw InvalidOrientation::fromClassNameAndField($this->class->name, $fieldName);
  1169. }
  1171. if (isset($this->class->fieldMappings[$fieldName])) {
  1172. $tableAlias = isset($this->class->fieldMappings[$fieldName]['inherited'])
  1173. ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
  1174. : $baseTableAlias;
  1176. $columnName = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  1177. $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1179. continue;
  1180. }
  1182. if (isset($this->class->associationMappings[$fieldName])) {
  1183. if (! $this->class->associationMappings[$fieldName]['isOwningSide']) {
  1184. throw InvalidFindByCall::fromInverseSideUsage($this->class->name, $fieldName);
  1185. }
  1187. $tableAlias = isset($this->class->associationMappings[$fieldName]['inherited'])
  1188. ? $this->getSQLTableAlias($this->class->associationMappings[$fieldName]['inherited'])
  1189. : $baseTableAlias;
  1191. foreach ($this->class->associationMappings[$fieldName]['joinColumns'] as $joinColumn) {
  1192. $columnName = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1193. $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1194. }
  1196. continue;
  1197. }
  1199. throw UnrecognizedField::byName($fieldName);
  1200. }
  1202. return ' ORDER BY ' . implode(', ', $orderByList);
  1203. }
  1205. /**
  1206. * Gets the SQL fragment with the list of columns to select when querying for
  1207. * an entity in this persister.
  1208. *
  1209. * Subclasses should override this method to alter or change the select column
  1210. * list SQL fragment. Note that in the implementation of BasicEntityPersister
  1211. * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
  1212. * Subclasses may or may not do the same.
  1213. *
  1214. * @return string The SQL fragment.
  1215. */
  1216. protected function getSelectColumnsSQL()
  1217. {
  1218. if ($this->currentPersisterContext->selectColumnListSql !== null) {
  1219. return $this->currentPersisterContext->selectColumnListSql;
  1220. }
  1222. $columnList = [];
  1223. $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r'); // r for root
  1225. // Add regular columns to select list
  1226. foreach ($this->class->fieldNames as $field) {
  1227. $columnList[] = $this->getSelectColumnSQL($field, $this->class);
  1228. }
  1230. $this->currentPersisterContext->selectJoinSql = '';
  1231. $eagerAliasCounter = 0;
  1233. foreach ($this->class->associationMappings as $assocField => $assoc) {
  1234. $assocColumnSQL = $this->getSelectColumnAssociationSQL($assocField, $assoc, $this->class);
  1236. if ($assocColumnSQL) {
  1237. $columnList[] = $assocColumnSQL;
  1238. }
  1240. $isAssocToOneInverseSide = $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
  1241. $isAssocFromOneEager = $assoc['type'] !== ClassMetadata::MANY_TO_MANY && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
  1243. if (! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
  1244. continue;
  1245. }
  1247. if ((($assoc['type'] & ClassMetadata::TO_MANY) > 0) && $this->currentPersisterContext->handlesLimits) {
  1248. continue;
  1249. }
  1251. $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1253. if ($eagerEntity->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  1254. continue; // now this is why you shouldn't use inheritance
  1255. }
  1257. $assocAlias = 'e' . ($eagerAliasCounter++);
  1258. $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc['targetEntity'], $assocAlias, 'r', $assocField);
  1260. foreach ($eagerEntity->fieldNames as $field) {
  1261. $columnList[] = $this->getSelectColumnSQL($field, $eagerEntity, $assocAlias);
  1262. }
  1264. foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
  1265. $eagerAssocColumnSQL = $this->getSelectColumnAssociationSQL(
  1266. $eagerAssocField,
  1267. $eagerAssoc,
  1268. $eagerEntity,
  1269. $assocAlias
  1270. );
  1272. if ($eagerAssocColumnSQL) {
  1273. $columnList[] = $eagerAssocColumnSQL;
  1274. }
  1275. }
  1277. $association = $assoc;
  1278. $joinCondition = [];
  1280. if (isset($assoc['indexBy'])) {
  1281. $this->currentPersisterContext->rsm->addIndexBy($assocAlias, $assoc['indexBy']);
  1282. }
  1284. if (! $assoc['isOwningSide']) {
  1285. $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1286. $association = $eagerEntity->getAssociationMapping($assoc['mappedBy']);
  1287. }
  1289. $joinTableAlias = $this->getSQLTableAlias($eagerEntity->name, $assocAlias);
  1290. $joinTableName = $this->quoteStrategy->getTableName($eagerEntity, $this->platform);
  1292. if ($assoc['isOwningSide']) {
  1293. $tableAlias = $this->getSQLTableAlias($association['targetEntity'], $assocAlias);
  1294. $this->currentPersisterContext->selectJoinSql .= ' ' . $this->getJoinSQLForJoinColumns($association['joinColumns']);
  1296. foreach ($association['joinColumns'] as $joinColumn) {
  1297. $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1298. $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1299. $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'])
  1300. . '.' . $sourceCol . ' = ' . $tableAlias . '.' . $targetCol;
  1301. }
  1303. // Add filter SQL
  1304. $filterSql = $this->generateFilterConditionSQL($eagerEntity, $tableAlias);
  1305. if ($filterSql) {
  1306. $joinCondition[] = $filterSql;
  1307. }
  1308. } else {
  1309. $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
  1311. foreach ($association['joinColumns'] as $joinColumn) {
  1312. $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1313. $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1315. $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'], $assocAlias) . '.' . $sourceCol . ' = '
  1316. . $this->getSQLTableAlias($association['targetEntity']) . '.' . $targetCol;
  1317. }
  1318. }
  1320. $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';
  1321. $this->currentPersisterContext->selectJoinSql .= implode(' AND ', $joinCondition);
  1322. }
  1324. $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
  1326. return $this->currentPersisterContext->selectColumnListSql;
  1327. }
  1329. /**
  1330. * Gets the SQL join fragment used when selecting entities from an association.
  1331. *
  1332. * @param string $field
  1333. * @param mixed[] $assoc
  1334. * @param string $alias
  1335. *
  1336. * @return string
  1337. */
  1338. protected function getSelectColumnAssociationSQL($field, $assoc, ClassMetadata $class, $alias = 'r')
  1339. {
  1340. if (! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)) {
  1341. return '';
  1342. }
  1344. $columnList = [];
  1345. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  1346. $isIdentifier = isset($assoc['id']) && $assoc['id'] === true;
  1347. $sqlTableAlias = $this->getSQLTableAlias($class->name, ($alias === 'r' ? '' : $alias));
  1349. foreach ($assoc['joinColumns'] as $joinColumn) {
  1350. $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1351. $resultColumnName = $this->getSQLColumnAlias($joinColumn['name']);
  1352. $type = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  1354. $this->currentPersisterContext->rsm->addMetaResult($alias, $resultColumnName, $joinColumn['name'], $isIdentifier, $type);
  1356. $columnList[] = sprintf('%s.%s AS %s', $sqlTableAlias, $quotedColumn, $resultColumnName);
  1357. }
  1359. return implode(', ', $columnList);
  1360. }
  1362. /**
  1363. * Gets the SQL join fragment used when selecting entities from a
  1364. * many-to-many association.
  1365. *
  1366. * @psalm-param array<string, mixed> $manyToMany
  1367. *
  1368. * @return string
  1369. */
  1370. protected function getSelectManyToManyJoinSQL(array $manyToMany)
  1371. {
  1372. $conditions = [];
  1373. $association = $manyToMany;
  1374. $sourceTableAlias = $this->getSQLTableAlias($this->class->name);
  1376. if (! $manyToMany['isOwningSide']) {
  1377. $targetEntity = $this->em->getClassMetadata($manyToMany['targetEntity']);
  1378. $association = $targetEntity->associationMappings[$manyToMany['mappedBy']];
  1379. }
  1381. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  1382. $joinColumns = $manyToMany['isOwningSide']
  1383. ? $association['joinTable']['inverseJoinColumns']
  1384. : $association['joinTable']['joinColumns'];
  1386. foreach ($joinColumns as $joinColumn) {
  1387. $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1388. $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1389. $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableName . '.' . $quotedSourceColumn;
  1390. }
  1392. return ' INNER JOIN ' . $joinTableName . ' ON ' . implode(' AND ', $conditions);
  1393. }
  1395. /**
  1396. * {@inheritdoc}
  1397. */
  1398. public function getInsertSQL()
  1399. {
  1400. if ($this->insertSql !== null) {
  1401. return $this->insertSql;
  1402. }
  1404. $columns = $this->getInsertColumnList();
  1405. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1407. if (empty($columns)) {
  1408. $identityColumn = $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class, $this->platform);
  1409. $this->insertSql = $this->platform->getEmptyIdentityInsertSQL($tableName, $identityColumn);
  1411. return $this->insertSql;
  1412. }
  1414. $values = [];
  1415. $columns = array_unique($columns);
  1417. foreach ($columns as $column) {
  1418. $placeholder = '?';
  1420. if (
  1421. isset($this->class->fieldNames[$column])
  1422. && isset($this->columnTypes[$this->class->fieldNames[$column]])
  1423. && isset($this->class->fieldMappings[$this->class->fieldNames[$column]]['requireSQLConversion'])
  1424. ) {
  1425. $type = Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
  1426. $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  1427. }
  1429. $values[] = $placeholder;
  1430. }
  1432. $columns = implode(', ', $columns);
  1433. $values = implode(', ', $values);
  1435. $this->insertSql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tableName, $columns, $values);
  1437. return $this->insertSql;
  1438. }
  1440. /**
  1441. * Gets the list of columns to put in the INSERT SQL statement.
  1442. *
  1443. * Subclasses should override this method to alter or change the list of
  1444. * columns placed in the INSERT statements used by the persister.
  1445. *
  1446. * @return string[] The list of columns.
  1447. * @psalm-return list<string>
  1448. */
  1449. protected function getInsertColumnList()
  1450. {
  1451. $columns = [];
  1453. foreach ($this->class->reflFields as $name => $field) {
  1454. if ($this->class->isVersioned && $this->class->versionField === $name) {
  1455. continue;
  1456. }
  1458. if (isset($this->class->embeddedClasses[$name])) {
  1459. continue;
  1460. }
  1462. if (isset($this->class->associationMappings[$name])) {
  1463. $assoc = $this->class->associationMappings[$name];
  1465. if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  1466. foreach ($assoc['joinColumns'] as $joinColumn) {
  1467. $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1468. }
  1469. }
  1471. continue;
  1472. }
  1474. if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] !== $name) {
  1475. if (isset($this->class->fieldMappings[$name]['notInsertable'])) {
  1476. continue;
  1477. }
  1479. $columns[] = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
  1480. $this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
  1481. }
  1482. }
  1484. return $columns;
  1485. }
  1487. /**
  1488. * Gets the SQL snippet of a qualified column name for the given field name.
  1489. *
  1490. * @param string $field The field name.
  1491. * @param ClassMetadata $class The class that declares this field. The table this class is
  1492. * mapped to must own the column for the given field.
  1493. * @param string $alias
  1494. *
  1495. * @return string
  1496. */
  1497. protected function getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r')
  1498. {
  1499. $root = $alias === 'r' ? '' : $alias;
  1500. $tableAlias = $this->getSQLTableAlias($class->name, $root);
  1501. $fieldMapping = $class->fieldMappings[$field];
  1502. $sql = sprintf('%s.%s', $tableAlias, $this->quoteStrategy->getColumnName($field, $class, $this->platform));
  1503. $columnAlias = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1505. $this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field);
  1507. if (isset($fieldMapping['requireSQLConversion'])) {
  1508. $type = Type::getType($fieldMapping['type']);
  1509. $sql = $type->convertToPHPValueSQL($sql, $this->platform);
  1510. }
  1512. return $sql . ' AS ' . $columnAlias;
  1513. }
  1515. /**
  1516. * Gets the SQL table alias for the given class name.
  1517. *
  1518. * @param string $className
  1519. * @param string $assocName
  1520. *
  1521. * @return string The SQL table alias.
  1522. *
  1523. * @todo Reconsider. Binding table aliases to class names is not such a good idea.
  1524. */
  1525. protected function getSQLTableAlias($className, $assocName = '')
  1526. {
  1527. if ($assocName) {
  1528. $className .= '#' . $assocName;
  1529. }
  1531. if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
  1532. return $this->currentPersisterContext->sqlTableAliases[$className];
  1533. }
  1535. $tableAlias = 't' . $this->currentPersisterContext->sqlAliasCounter++;
  1537. $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
  1539. return $tableAlias;
  1540. }
  1542. /**
  1543. * {@inheritdoc}
  1544. */
  1545. public function lock(array $criteria, $lockMode)
  1546. {
  1547. $lockSql = '';
  1548. $conditionSql = $this->getSelectConditionSQL($criteria);
  1550. switch ($lockMode) {
  1551. case LockMode::PESSIMISTIC_READ:
  1552. $lockSql = $this->platform->getReadLockSQL();
  1554. break;
  1555. case LockMode::PESSIMISTIC_WRITE:
  1556. $lockSql = $this->platform->getWriteLockSQL();
  1557. break;
  1558. }
  1560. $lock = $this->getLockTablesSql($lockMode);
  1561. $where = ($conditionSql ? ' WHERE ' . $conditionSql : '') . ' ';
  1562. $sql = 'SELECT 1 '
  1563. . $lock
  1564. . $where
  1565. . $lockSql;
  1567. [$params, $types] = $this->expandParameters($criteria);
  1569. $this->conn->executeQuery($sql, $params, $types);
  1570. }
  1572. /**
  1573. * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
  1574. *
  1575. * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants.
  1576. * @psalm-param LockMode::*|null $lockMode
  1577. *
  1578. * @return string
  1579. */
  1580. protected function getLockTablesSql($lockMode)
  1581. {
  1582. return $this->platform->appendLockHint(
  1583. 'FROM '
  1584. . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
  1585. . $this->getSQLTableAlias($this->class->name),
  1586. $lockMode ?? LockMode::NONE
  1587. );
  1588. }
  1590. /**
  1591. * Gets the Select Where Condition from a Criteria object.
  1592. *
  1593. * @return string
  1594. */
  1595. protected function getSelectConditionCriteriaSQL(Criteria $criteria)
  1596. {
  1597. $expression = $criteria->getWhereExpression();
  1599. if ($expression === null) {
  1600. return '';
  1601. }
  1603. $visitor = new SqlExpressionVisitor($this, $this->class);
  1605. return $visitor->dispatch($expression);
  1606. }
  1608. /**
  1609. * {@inheritdoc}
  1610. */
  1611. public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
  1612. {
  1613. $selectedColumns = [];
  1614. $columns = $this->getSelectConditionStatementColumnSQL($field, $assoc);
  1616. if (count($columns) > 1 && $comparison === Comparison::IN) {
  1617. /*
  1618. * @todo try to support multi-column IN expressions.
  1619. * Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
  1620. */
  1621. throw CantUseInOperatorOnCompositeKeys::create();
  1622. }
  1624. foreach ($columns as $column) {
  1625. $placeholder = '?';
  1627. if (isset($this->class->fieldMappings[$field]['requireSQLConversion'])) {
  1628. $type = Type::getType($this->class->fieldMappings[$field]['type']);
  1629. $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->platform);
  1630. }
  1632. if ($comparison !== null) {
  1633. // special case null value handling
  1634. if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && $value === null) {
  1635. $selectedColumns[] = $column . ' IS NULL';
  1637. continue;
  1638. }
  1640. if ($comparison === Comparison::NEQ && $value === null) {
  1641. $selectedColumns[] = $column . ' IS NOT NULL';
  1643. continue;
  1644. }
  1646. $selectedColumns[] = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
  1648. continue;
  1649. }
  1651. if (is_array($value)) {
  1652. $in = sprintf('%s IN (%s)', $column, $placeholder);
  1654. if (array_search(null, $value, true) !== false) {
  1655. $selectedColumns[] = sprintf('(%s OR %s IS NULL)', $in, $column);
  1657. continue;
  1658. }
  1660. $selectedColumns[] = $in;
  1662. continue;
  1663. }
  1665. if ($value === null) {
  1666. $selectedColumns[] = sprintf('%s IS NULL', $column);
  1668. continue;
  1669. }
  1671. $selectedColumns[] = sprintf('%s = %s', $column, $placeholder);
  1672. }
  1674. return implode(' AND ', $selectedColumns);
  1675. }
  1677. /**
  1678. * Builds the left-hand-side of a where condition statement.
  1679. *
  1680. * @psalm-param array<string, mixed>|null $assoc
  1681. *
  1682. * @return string[]
  1683. * @psalm-return list<string>
  1684. *
  1685. * @throws InvalidFindByCall
  1686. * @throws UnrecognizedField
  1687. */
  1688. private function getSelectConditionStatementColumnSQL(
  1689. string $field,
  1690. ?array $assoc = null
  1691. ): array {
  1692. if (isset($this->class->fieldMappings[$field])) {
  1693. $className = $this->class->fieldMappings[$field]['inherited'] ?? $this->class->name;
  1695. return [$this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getColumnName($field, $this->class, $this->platform)];
  1696. }
  1698. if (isset($this->class->associationMappings[$field])) {
  1699. $association = $this->class->associationMappings[$field];
  1700. // Many-To-Many requires join table check for joinColumn
  1701. $columns = [];
  1702. $class = $this->class;
  1704. if ($association['type'] === ClassMetadata::MANY_TO_MANY) {
  1705. if (! $association['isOwningSide']) {
  1706. $association = $assoc;
  1707. }
  1709. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1710. $joinColumns = $assoc['isOwningSide']
  1711. ? $association['joinTable']['joinColumns']
  1712. : $association['joinTable']['inverseJoinColumns'];
  1714. foreach ($joinColumns as $joinColumn) {
  1715. $columns[] = $joinTableName . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1716. }
  1717. } else {
  1718. if (! $association['isOwningSide']) {
  1719. throw InvalidFindByCall::fromInverseSideUsage(
  1720. $this->class->name,
  1721. $field
  1722. );
  1723. }
  1725. $className = $association['inherited'] ?? $this->class->name;
  1727. foreach ($association['joinColumns'] as $joinColumn) {
  1728. $columns[] = $this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1729. }
  1730. }
  1732. return $columns;
  1733. }
  1735. if ($assoc !== null && strpos($field, ' ') === false && strpos($field, '(') === false) {
  1736. // very careless developers could potentially open up this normally hidden api for userland attacks,
  1737. // therefore checking for spaces and function calls which are not allowed.
  1739. // found a join column condition, not really a "field"
  1740. return [$field];
  1741. }
  1743. throw UnrecognizedField::byName($field);
  1744. }
  1746. /**
  1747. * Gets the conditional SQL fragment used in the WHERE clause when selecting
  1748. * entities in this persister.
  1749. *
  1750. * Subclasses are supposed to override this method if they intend to change
  1751. * or alter the criteria by which entities are selected.
  1752. *
  1753. * @param mixed[]|null $assoc
  1754. * @psalm-param array<string, mixed> $criteria
  1755. * @psalm-param array<string, mixed>|null $assoc
  1756. *
  1757. * @return string
  1758. */
  1759. protected function getSelectConditionSQL(array $criteria, $assoc = null)
  1760. {
  1761. $conditions = [];
  1763. foreach ($criteria as $field => $value) {
  1764. $conditions[] = $this->getSelectConditionStatementSQL($field, $value, $assoc);
  1765. }
  1767. return implode(' AND ', $conditions);
  1768. }
  1770. /**
  1771. * {@inheritdoc}
  1772. */
  1773. public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1774. {
  1775. $this->switchPersisterContext($offset, $limit);
  1777. $stmt = $this->getOneToManyStatement($assoc, $sourceEntity, $offset, $limit);
  1779. return $this->loadArrayFromResult($assoc, $stmt);
  1780. }
  1782. /**
  1783. * {@inheritdoc}
  1784. */
  1785. public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1786. {
  1787. $stmt = $this->getOneToManyStatement($assoc, $sourceEntity);
  1789. return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1790. }
  1792. /**
  1793. * Builds criteria and execute SQL statement to fetch the one to many entities from.
  1794. *
  1795. * @param object $sourceEntity
  1796. * @psalm-param array<string, mixed> $assoc
  1797. */
  1798. private function getOneToManyStatement(
  1799. array $assoc,
  1800. $sourceEntity,
  1801. ?int $offset = null,
  1802. ?int $limit = null
  1803. ): Result {
  1804. $this->switchPersisterContext($offset, $limit);
  1806. $criteria = [];
  1807. $parameters = [];
  1808. $owningAssoc = $this->class->associationMappings[$assoc['mappedBy']];
  1809. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1810. $tableAlias = $this->getSQLTableAlias($owningAssoc['inherited'] ?? $this->class->name);
  1812. foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  1813. if ($sourceClass->containsForeignIdentifier) {
  1814. $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1815. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1817. if (isset($sourceClass->associationMappings[$field])) {
  1818. $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1819. $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1820. }
  1822. $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1823. $parameters[] = [
  1824. 'value' => $value,
  1825. 'field' => $field,
  1826. 'class' => $sourceClass,
  1827. ];
  1829. continue;
  1830. }
  1832. $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1833. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1835. $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1836. $parameters[] = [
  1837. 'value' => $value,
  1838. 'field' => $field,
  1839. 'class' => $sourceClass,
  1840. ];
  1841. }
  1843. $sql = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1844. [$params, $types] = $this->expandToManyParameters($parameters);
  1846. return $this->conn->executeQuery($sql, $params, $types);
  1847. }
  1849. /**
  1850. * {@inheritdoc}
  1851. */
  1852. public function expandParameters($criteria)
  1853. {
  1854. $params = [];
  1855. $types = [];
  1857. foreach ($criteria as $field => $value) {
  1858. if ($value === null) {
  1859. continue; // skip null values.
  1860. }
  1862. $types = array_merge($types, $this->getTypes($field, $value, $this->class));
  1863. $params = array_merge($params, $this->getValues($value));
  1864. }
  1866. return [$params, $types];
  1867. }
  1869. /**
  1870. * Expands the parameters from the given criteria and use the correct binding types if found,
  1871. * specialized for OneToMany or ManyToMany associations.
  1872. *
  1873. * @param mixed[][] $criteria an array of arrays containing following:
  1874. * - field to which each criterion will be bound
  1875. * - value to be bound
  1876. * - class to which the field belongs to
  1877. *
  1878. * @return mixed[][]
  1879. * @psalm-return array{0: array, 1: list<int|string|null>}
  1880. */
  1881. private function expandToManyParameters(array $criteria): array
  1882. {
  1883. $params = [];
  1884. $types = [];
  1886. foreach ($criteria as $criterion) {
  1887. if ($criterion['value'] === null) {
  1888. continue; // skip null values.
  1889. }
  1891. $types = array_merge($types, $this->getTypes($criterion['field'], $criterion['value'], $criterion['class']));
  1892. $params = array_merge($params, $this->getValues($criterion['value']));
  1893. }
  1895. return [$params, $types];
  1896. }
  1898. /**
  1899. * Infers field types to be used by parameter type casting.
  1900. *
  1901. * @param mixed $value
  1902. *
  1903. * @return int[]|null[]|string[]
  1904. * @psalm-return list<int|string|null>
  1905. *
  1906. * @throws QueryException
  1907. */
  1908. private function getTypes(string $field, $value, ClassMetadata $class): array
  1909. {
  1910. $types = [];
  1912. switch (true) {
  1913. case isset($class->fieldMappings[$field]):
  1914. $types = array_merge($types, [$class->fieldMappings[$field]['type']]);
  1915. break;
  1917. case isset($class->associationMappings[$field]):
  1918. $assoc = $class->associationMappings[$field];
  1919. $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1921. if (! $assoc['isOwningSide']) {
  1922. $assoc = $class->associationMappings[$assoc['mappedBy']];
  1923. $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1924. }
  1926. $columns = $assoc['type'] === ClassMetadata::MANY_TO_MANY
  1927. ? $assoc['relationToTargetKeyColumns']
  1928. : $assoc['sourceToTargetKeyColumns'];
  1930. foreach ($columns as $column) {
  1931. $types[] = PersisterHelper::getTypeOfColumn($column, $class, $this->em);
  1932. }
  1934. break;
  1936. default:
  1937. $types[] = null;
  1938. break;
  1939. }
  1941. if (is_array($value)) {
  1942. return array_map(static function ($type) {
  1943. $type = Type::getType($type);
  1945. return $type->getBindingType() + Connection::ARRAY_PARAM_OFFSET;
  1946. }, $types);
  1947. }
  1949. return $types;
  1950. }
  1952. /**
  1953. * Retrieves the parameters that identifies a value.
  1954. *
  1955. * @param mixed $value
  1956. *
  1957. * @return mixed[]
  1958. */
  1959. private function getValues($value): array
  1960. {
  1961. if (is_array($value)) {
  1962. $newValue = [];
  1964. foreach ($value as $itemValue) {
  1965. $newValue = array_merge($newValue, $this->getValues($itemValue));
  1966. }
  1968. return [$newValue];
  1969. }
  1971. return $this->getIndividualValue($value);
  1972. }
  1974. /**
  1975. * Retrieves an individual parameter value.
  1976. *
  1977. * @param mixed $value
  1978. *
  1979. * @return array<mixed>
  1980. * @psalm-return list<mixed>
  1981. */
  1982. private function getIndividualValue($value)
  1983. {
  1984. if (! is_object($value)) {
  1985. return [$value];
  1986. }
  1988. $valueClass = ClassUtils::getClass($value);
  1990. if ($this->em->getMetadataFactory()->isTransient($valueClass)) {
  1991. return [$value];
  1992. }
  1994. $class = $this->em->getClassMetadata($valueClass);
  1996. if ($class->isIdentifierComposite) {
  1997. $newValue = [];
  1999. foreach ($class->getIdentifierValues($value) as $innerValue) {
  2000. $newValue = array_merge($newValue, $this->getValues($innerValue));
  2001. }
  2003. return $newValue;
  2004. }
  2006. return [$this->em->getUnitOfWork()->getSingleIdentifierValue($value)];
  2007. }
  2009. /**
  2010. * {@inheritdoc}
  2011. */
  2012. public function exists($entity, ?Criteria $extraConditions = null)
  2013. {
  2014. $criteria = $this->class->getIdentifierValues($entity);
  2016. if (! $criteria) {
  2017. return false;
  2018. }
  2020. $alias = $this->getSQLTableAlias($this->class->name);
  2022. $sql = 'SELECT 1 '
  2023. . $this->getLockTablesSql(null)
  2024. . ' WHERE ' . $this->getSelectConditionSQL($criteria);
  2026. [$params, $types] = $this->expandParameters($criteria);
  2028. if ($extraConditions !== null) {
  2029. $sql .= ' AND ' . $this->getSelectConditionCriteriaSQL($extraConditions);
  2030. [$criteriaParams, $criteriaTypes] = $this->expandCriteriaParameters($extraConditions);
  2032. $params = array_merge($params, $criteriaParams);
  2033. $types = array_merge($types, $criteriaTypes);
  2034. }
  2036. $filterSql = $this->generateFilterConditionSQL($this->class, $alias);
  2037. if ($filterSql) {
  2038. $sql .= ' AND ' . $filterSql;
  2039. }
  2041. return (bool) $this->conn->fetchOne($sql, $params, $types);
  2042. }
  2044. /**
  2045. * Generates the appropriate join SQL for the given join column.
  2046. *
  2047. * @param array[] $joinColumns The join columns definition of an association.
  2048. * @psalm-param array<array<string, mixed>> $joinColumns
  2049. *
  2050. * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
  2051. */
  2052. protected function getJoinSQLForJoinColumns($joinColumns)
  2053. {
  2054. // if one of the join columns is nullable, return left join
  2055. foreach ($joinColumns as $joinColumn) {
  2056. if (! isset($joinColumn['nullable']) || $joinColumn['nullable']) {
  2057. return 'LEFT JOIN';
  2058. }
  2059. }
  2061. return 'INNER JOIN';
  2062. }
  2064. /**
  2065. * @param string $columnName
  2066. *
  2067. * @return string
  2068. */
  2069. public function getSQLColumnAlias($columnName)
  2070. {
  2071. return $this->quoteStrategy->getColumnAlias($columnName, $this->currentPersisterContext->sqlAliasCounter++, $this->platform);
  2072. }
  2074. /**
  2075. * Generates the filter SQL for a given entity and table alias.
  2076. *
  2077. * @param ClassMetadata $targetEntity Metadata of the target entity.
  2078. * @param string $targetTableAlias The table alias of the joined/selected table.
  2079. *
  2080. * @return string The SQL query part to add to a query.
  2081. */
  2082. protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
  2083. {
  2084. $filterClauses = [];
  2086. foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  2087. $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  2088. if ($filterExpr !== '') {
  2089. $filterClauses[] = '(' . $filterExpr . ')';
  2090. }
  2091. }
  2093. $sql = implode(' AND ', $filterClauses);
  2095. return $sql ? '(' . $sql . ')' : ''; // Wrap again to avoid "X or Y and FilterConditionSQL"
  2096. }
  2098. /**
  2099. * Switches persister context according to current query offset/limits
  2100. *
  2101. * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
  2102. *
  2103. * @param int|null $offset
  2104. * @param int|null $limit
  2105. *
  2106. * @return void
  2107. */
  2108. protected function switchPersisterContext($offset, $limit)
  2109. {
  2110. if ($offset === null && $limit === null) {
  2111. $this->currentPersisterContext = $this->noLimitsContext;
  2113. return;
  2114. }
  2116. $this->currentPersisterContext = $this->limitsHandlingContext;
  2117. }
  2119. /**
  2120. * @return string[]
  2121. * @psalm-return list<string>
  2122. */
  2123. protected function getClassIdentifiersTypes(ClassMetadata $class): array
  2124. {
  2125. $entityManager = $this->em;
  2127. return array_map(
  2128. static function ($fieldName) use ($class, $entityManager): string {
  2129. $types = PersisterHelper::getTypeOfField($fieldName, $class, $entityManager);
  2130. assert(isset($types[0]));
  2132. return $types[0];
  2133. },
  2134. $class->identifier
  2135. );
  2136. }
  2137. }