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

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\Common\Util\ClassUtils;
  11. use Doctrine\DBAL\Connection;
  12. use Doctrine\DBAL\LockMode;
  13. use Doctrine\DBAL\Platforms\AbstractPlatform;
  14. use Doctrine\DBAL\Result;
  15. use Doctrine\DBAL\Types\Type;
  16. use Doctrine\DBAL\Types\Types;
  17. use Doctrine\Deprecations\Deprecation;
  18. use Doctrine\ORM\EntityManagerInterface;
  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\Query;
  30. use Doctrine\ORM\Query\QueryException;
  31. use Doctrine\ORM\Repository\Exception\InvalidFindByCall;
  32. use Doctrine\ORM\UnitOfWork;
  33. use Doctrine\ORM\Utility\IdentifierFlattener;
  34. use Doctrine\ORM\Utility\PersisterHelper;
  35. use LengthException;
  37. use function array_combine;
  38. use function array_keys;
  39. use function array_map;
  40. use function array_merge;
  41. use function array_search;
  42. use function array_unique;
  43. use function array_values;
  44. use function assert;
  45. use function count;
  46. use function implode;
  47. use function is_array;
  48. use function is_object;
  49. use function reset;
  50. use function spl_object_id;
  51. use function sprintf;
  52. use function str_contains;
  53. use function strtoupper;
  54. use function trim;
  56. /**
  57. * A BasicEntityPersister maps an entity to a single table in a relational database.
  58. *
  59. * A persister is always responsible for a single entity type.
  60. *
  61. * EntityPersisters are used during a UnitOfWork to apply any changes to the persistent
  62. * state of entities onto a relational database when the UnitOfWork is committed,
  63. * as well as for basic querying of entities and their associations (not DQL).
  64. *
  65. * The persisting operations that are invoked during a commit of a UnitOfWork to
  66. * persist the persistent entity state are:
  67. *
  68. * - {@link addInsert} : To schedule an entity for insertion.
  69. * - {@link executeInserts} : To execute all scheduled insertions.
  70. * - {@link update} : To update the persistent state of an entity.
  71. * - {@link delete} : To delete the persistent state of an entity.
  72. *
  73. * As can be seen from the above list, insertions are batched and executed all at once
  74. * for increased efficiency.
  75. *
  76. * The querying operations invoked during a UnitOfWork, either through direct find
  77. * requests or lazy-loading, are the following:
  78. *
  79. * - {@link load} : Loads (the state of) a single, managed entity.
  80. * - {@link loadAll} : Loads multiple, managed entities.
  81. * - {@link loadOneToOneEntity} : Loads a one/many-to-one entity association (lazy-loading).
  82. * - {@link loadOneToManyCollection} : Loads a one-to-many entity association (lazy-loading).
  83. * - {@link loadManyToManyCollection} : Loads a many-to-many entity association (lazy-loading).
  84. *
  85. * The BasicEntityPersister implementation provides the default behavior for
  86. * persisting and querying entities that are mapped to a single database table.
  87. *
  88. * Subclasses can be created to provide custom persisting and querying strategies,
  89. * i.e. spanning multiple tables.
  90. */
  91. class BasicEntityPersister implements EntityPersister
  92. {
  93. /** @var array<string,string> */
  94. private static $comparisonMap = [
  95. Comparison::EQ => '= %s',
  96. Comparison::NEQ => '!= %s',
  97. Comparison::GT => '> %s',
  98. Comparison::GTE => '>= %s',
  99. Comparison::LT => '< %s',
  100. Comparison::LTE => '<= %s',
  101. Comparison::IN => 'IN (%s)',
  102. Comparison::NIN => 'NOT IN (%s)',
  103. Comparison::CONTAINS => 'LIKE %s',
  104. Comparison::STARTS_WITH => 'LIKE %s',
  105. Comparison::ENDS_WITH => 'LIKE %s',
  106. ];
  108. /**
  109. * Metadata object that describes the mapping of the mapped entity class.
  110. *
  111. * @var ClassMetadata
  112. */
  113. protected $class;
  115. /**
  116. * The underlying DBAL Connection of the used EntityManager.
  117. *
  118. * @var Connection $conn
  119. */
  120. protected $conn;
  122. /**
  123. * The database platform.
  124. *
  125. * @var AbstractPlatform
  126. */
  127. protected $platform;
  129. /**
  130. * The EntityManager instance.
  131. *
  132. * @var EntityManagerInterface
  133. */
  134. protected $em;
  136. /**
  137. * Queued inserts.
  138. *
  139. * @psalm-var array<int, object>
  140. */
  141. protected $queuedInserts = [];
  143. /**
  144. * The map of column names to DBAL mapping types of all prepared columns used
  145. * when INSERTing or UPDATEing an entity.
  146. *
  147. * @see prepareInsertData($entity)
  148. * @see prepareUpdateData($entity)
  149. *
  150. * @var mixed[]
  151. */
  152. protected $columnTypes = [];
  154. /**
  155. * The map of quoted column names.
  156. *
  157. * @see prepareInsertData($entity)
  158. * @see prepareUpdateData($entity)
  159. *
  160. * @var mixed[]
  161. */
  162. protected $quotedColumns = [];
  164. /**
  165. * The INSERT SQL statement used for entities handled by this persister.
  166. * This SQL is only generated once per request, if at all.
  167. *
  168. * @var string|null
  169. */
  170. private $insertSql;
  172. /**
  173. * The quote strategy.
  174. *
  175. * @var QuoteStrategy
  176. */
  177. protected $quoteStrategy;
  179. /**
  180. * The IdentifierFlattener used for manipulating identifiers
  181. *
  182. * @var IdentifierFlattener
  183. */
  184. private $identifierFlattener;
  186. /** @var CachedPersisterContext */
  187. protected $currentPersisterContext;
  189. /** @var CachedPersisterContext */
  190. private $limitsHandlingContext;
  192. /** @var CachedPersisterContext */
  193. private $noLimitsContext;
  195. /**
  196. * Initializes a new <tt>BasicEntityPersister</tt> that uses the given EntityManager
  197. * and persists instances of the class described by the given ClassMetadata descriptor.
  198. */
  199. public function __construct(EntityManagerInterface $em, ClassMetadata $class)
  200. {
  201. $this->em = $em;
  202. $this->class = $class;
  203. $this->conn = $em->getConnection();
  204. $this->platform = $this->conn->getDatabasePlatform();
  205. $this->quoteStrategy = $em->getConfiguration()->getQuoteStrategy();
  206. $this->identifierFlattener = new IdentifierFlattener($em->getUnitOfWork(), $em->getMetadataFactory());
  207. $this->noLimitsContext = $this->currentPersisterContext = new CachedPersisterContext(
  208. $class,
  209. new Query\ResultSetMapping(),
  210. false
  211. );
  212. $this->limitsHandlingContext = new CachedPersisterContext(
  213. $class,
  214. new Query\ResultSetMapping(),
  215. true
  216. );
  217. }
  219. /**
  220. * {@inheritdoc}
  221. */
  222. public function getClassMetadata()
  223. {
  224. return $this->class;
  225. }
  227. /**
  228. * {@inheritdoc}
  229. */
  230. public function getResultSetMapping()
  231. {
  232. return $this->currentPersisterContext->rsm;
  233. }
  235. /**
  236. * {@inheritdoc}
  237. */
  238. public function addInsert($entity)
  239. {
  240. $this->queuedInserts[spl_object_id($entity)] = $entity;
  241. }
  243. /**
  244. * {@inheritdoc}
  245. */
  246. public function getInserts()
  247. {
  248. return $this->queuedInserts;
  249. }
  251. /**
  252. * {@inheritdoc}
  253. */
  254. public function executeInserts()
  255. {
  256. if (! $this->queuedInserts) {
  257. return [];
  258. }
  260. $postInsertIds = [];
  261. $idGenerator = $this->class->idGenerator;
  262. $isPostInsertId = $idGenerator->isPostInsertGenerator();
  264. $stmt = $this->conn->prepare($this->getInsertSQL());
  265. $tableName = $this->class->getTableName();
  267. foreach ($this->queuedInserts as $entity) {
  268. $insertData = $this->prepareInsertData($entity);
  270. if (isset($insertData[$tableName])) {
  271. $paramIndex = 1;
  273. foreach ($insertData[$tableName] as $column => $value) {
  274. $stmt->bindValue($paramIndex++, $value, $this->columnTypes[$column]);
  275. }
  276. }
  278. $stmt->executeStatement();
  280. if ($isPostInsertId) {
  281. $generatedId = $idGenerator->generateId($this->em, $entity);
  282. $id = [$this->class->identifier[0] => $generatedId];
  283. $postInsertIds[] = [
  284. 'generatedId' => $generatedId,
  285. 'entity' => $entity,
  286. ];
  287. } else {
  288. $id = $this->class->getIdentifierValues($entity);
  289. }
  291. if ($this->class->requiresFetchAfterChange) {
  292. $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  293. }
  294. }
  296. $this->queuedInserts = [];
  298. return $postInsertIds;
  299. }
  301. /**
  302. * Retrieves the default version value which was created
  303. * by the preceding INSERT statement and assigns it back in to the
  304. * entities version field if the given entity is versioned.
  305. * Also retrieves values of columns marked as 'non insertable' and / or
  306. * 'not updatable' and assigns them back to the entities corresponding fields.
  307. *
  308. * @param object $entity
  309. * @param mixed[] $id
  310. *
  311. * @return void
  312. */
  313. protected function assignDefaultVersionAndUpsertableValues($entity, array $id)
  314. {
  315. $values = $this->fetchVersionAndNotUpsertableValues($this->class, $id);
  317. foreach ($values as $field => $value) {
  318. $value = Type::getType($this->class->fieldMappings[$field]['type'])->convertToPHPValue($value, $this->platform);
  320. $this->class->setFieldValue($entity, $field, $value);
  321. }
  322. }
  324. /**
  325. * Fetches the current version value of a versioned entity and / or the values of fields
  326. * marked as 'not insertable' and / or 'not updatable'.
  327. *
  328. * @param ClassMetadata $versionedClass
  329. * @param mixed[] $id
  330. *
  331. * @return mixed
  332. */
  333. protected function fetchVersionAndNotUpsertableValues($versionedClass, array $id)
  334. {
  335. $columnNames = [];
  336. foreach ($this->class->fieldMappings as $key => $column) {
  337. if (isset($column['generated']) || ($this->class->isVersioned && $key === $versionedClass->versionField)) {
  338. $columnNames[$key] = $this->quoteStrategy->getColumnName($key, $versionedClass, $this->platform);
  339. }
  340. }
  342. $tableName = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
  343. $identifier = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
  345. // FIXME: Order with composite keys might not be correct
  346. $sql = 'SELECT ' . implode(', ', $columnNames)
  347. . ' FROM ' . $tableName
  348. . ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
  350. $flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
  352. $values = $this->conn->fetchNumeric(
  353. $sql,
  354. array_values($flatId),
  355. $this->extractIdentifierTypes($id, $versionedClass)
  356. );
  358. if ($values === false) {
  359. throw new LengthException('Unexpected empty result for database query.');
  360. }
  362. $values = array_combine(array_keys($columnNames), $values);
  364. if (! $values) {
  365. throw new LengthException('Unexpected number of database columns.');
  366. }
  368. return $values;
  369. }
  371. /**
  372. * @param mixed[] $id
  373. *
  374. * @return int[]|null[]|string[]
  375. * @psalm-return list<int|string|null>
  376. */
  377. private function extractIdentifierTypes(array $id, ClassMetadata $versionedClass): array
  378. {
  379. $types = [];
  381. foreach ($id as $field => $value) {
  382. $types = array_merge($types, $this->getTypes($field, $value, $versionedClass));
  383. }
  385. return $types;
  386. }
  388. /**
  389. * {@inheritdoc}
  390. */
  391. public function update($entity)
  392. {
  393. $tableName = $this->class->getTableName();
  394. $updateData = $this->prepareUpdateData($entity);
  396. if (! isset($updateData[$tableName])) {
  397. return;
  398. }
  400. $data = $updateData[$tableName];
  402. if (! $data) {
  403. return;
  404. }
  406. $isVersioned = $this->class->isVersioned;
  407. $quotedTableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  409. $this->updateTable($entity, $quotedTableName, $data, $isVersioned);
  411. if ($this->class->requiresFetchAfterChange) {
  412. $id = $this->class->getIdentifierValues($entity);
  414. $this->assignDefaultVersionAndUpsertableValues($entity, $id);
  415. }
  416. }
  418. /**
  419. * Performs an UPDATE statement for an entity on a specific table.
  420. * The UPDATE can optionally be versioned, which requires the entity to have a version field.
  421. *
  422. * @param object $entity The entity object being updated.
  423. * @param string $quotedTableName The quoted name of the table to apply the UPDATE on.
  424. * @param mixed[] $updateData The map of columns to update (column => value).
  425. * @param bool $versioned Whether the UPDATE should be versioned.
  426. *
  427. * @throws UnrecognizedField
  428. * @throws OptimisticLockException
  429. */
  430. final protected function updateTable(
  431. $entity,
  432. $quotedTableName,
  433. array $updateData,
  434. $versioned = false
  435. ): void {
  436. $set = [];
  437. $types = [];
  438. $params = [];
  440. foreach ($updateData as $columnName => $value) {
  441. $placeholder = '?';
  442. $column = $columnName;
  444. switch (true) {
  445. case isset($this->class->fieldNames[$columnName]):
  446. $fieldName = $this->class->fieldNames[$columnName];
  447. $column = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  449. if (isset($this->class->fieldMappings[$fieldName]['requireSQLConversion'])) {
  450. $type = Type::getType($this->columnTypes[$columnName]);
  451. $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  452. }
  454. break;
  456. case isset($this->quotedColumns[$columnName]):
  457. $column = $this->quotedColumns[$columnName];
  459. break;
  460. }
  462. $params[] = $value;
  463. $set[] = $column . ' = ' . $placeholder;
  464. $types[] = $this->columnTypes[$columnName];
  465. }
  467. $where = [];
  468. $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  470. foreach ($this->class->identifier as $idField) {
  471. if (! isset($this->class->associationMappings[$idField])) {
  472. $params[] = $identifier[$idField];
  473. $types[] = $this->class->fieldMappings[$idField]['type'];
  474. $where[] = $this->quoteStrategy->getColumnName($idField, $this->class, $this->platform);
  476. continue;
  477. }
  479. $params[] = $identifier[$idField];
  480. $where[] = $this->quoteStrategy->getJoinColumnName(
  481. $this->class->associationMappings[$idField]['joinColumns'][0],
  482. $this->class,
  483. $this->platform
  484. );
  486. $targetMapping = $this->em->getClassMetadata($this->class->associationMappings[$idField]['targetEntity']);
  487. $targetType = PersisterHelper::getTypeOfField($targetMapping->identifier[0], $targetMapping, $this->em);
  489. if ($targetType === []) {
  490. throw UnrecognizedField::byFullyQualifiedName($this->class->name, $targetMapping->identifier[0]);
  491. }
  493. $types[] = reset($targetType);
  494. }
  496. if ($versioned) {
  497. $versionField = $this->class->versionField;
  498. assert($versionField !== null);
  499. $versionFieldType = $this->class->fieldMappings[$versionField]['type'];
  500. $versionColumn = $this->quoteStrategy->getColumnName($versionField, $this->class, $this->platform);
  502. $where[] = $versionColumn;
  503. $types[] = $this->class->fieldMappings[$versionField]['type'];
  504. $params[] = $this->class->reflFields[$versionField]->getValue($entity);
  506. switch ($versionFieldType) {
  507. case Types::SMALLINT:
  508. case Types::INTEGER:
  509. case Types::BIGINT:
  510. $set[] = $versionColumn . ' = ' . $versionColumn . ' + 1';
  511. break;
  513. case Types::DATETIME_MUTABLE:
  514. $set[] = $versionColumn . ' = CURRENT_TIMESTAMP';
  515. break;
  516. }
  517. }
  519. $sql = 'UPDATE ' . $quotedTableName
  520. . ' SET ' . implode(', ', $set)
  521. . ' WHERE ' . implode(' = ? AND ', $where) . ' = ?';
  523. $result = $this->conn->executeStatement($sql, $params, $types);
  525. if ($versioned && ! $result) {
  526. throw OptimisticLockException::lockFailed($entity);
  527. }
  528. }
  530. /**
  531. * @param array<mixed> $identifier
  532. * @param string[] $types
  533. *
  534. * @todo Add check for platform if it supports foreign keys/cascading.
  535. */
  536. protected function deleteJoinTableRecords(array $identifier, array $types): void
  537. {
  538. foreach ($this->class->associationMappings as $mapping) {
  539. if ($mapping['type'] !== ClassMetadata::MANY_TO_MANY) {
  540. continue;
  541. }
  543. // @Todo this only covers scenarios with no inheritance or of the same level. Is there something
  544. // like self-referential relationship between different levels of an inheritance hierarchy? I hope not!
  545. $selfReferential = ($mapping['targetEntity'] === $mapping['sourceEntity']);
  546. $class = $this->class;
  547. $association = $mapping;
  548. $otherColumns = [];
  549. $otherKeys = [];
  550. $keys = [];
  552. if (! $mapping['isOwningSide']) {
  553. $class = $this->em->getClassMetadata($mapping['targetEntity']);
  554. $association = $class->associationMappings[$mapping['mappedBy']];
  555. }
  557. $joinColumns = $mapping['isOwningSide']
  558. ? $association['joinTable']['joinColumns']
  559. : $association['joinTable']['inverseJoinColumns'];
  561. if ($selfReferential) {
  562. $otherColumns = ! $mapping['isOwningSide']
  563. ? $association['joinTable']['joinColumns']
  564. : $association['joinTable']['inverseJoinColumns'];
  565. }
  567. foreach ($joinColumns as $joinColumn) {
  568. $keys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  569. }
  571. foreach ($otherColumns as $joinColumn) {
  572. $otherKeys[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  573. }
  575. if (isset($mapping['isOnDeleteCascade'])) {
  576. continue;
  577. }
  579. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  581. $this->conn->delete($joinTableName, array_combine($keys, $identifier), $types);
  583. if ($selfReferential) {
  584. $this->conn->delete($joinTableName, array_combine($otherKeys, $identifier), $types);
  585. }
  586. }
  587. }
  589. /**
  590. * {@inheritdoc}
  591. */
  592. public function delete($entity)
  593. {
  594. $class = $this->class;
  595. $identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
  596. $tableName = $this->quoteStrategy->getTableName($class, $this->platform);
  597. $idColumns = $this->quoteStrategy->getIdentifierColumnNames($class, $this->platform);
  598. $id = array_combine($idColumns, $identifier);
  599. $types = $this->getClassIdentifiersTypes($class);
  601. $this->deleteJoinTableRecords($identifier, $types);
  603. return (bool) $this->conn->delete($tableName, $id, $types);
  604. }
  606. /**
  607. * Prepares the changeset of an entity for database insertion (UPDATE).
  608. *
  609. * The changeset is obtained from the currently running UnitOfWork.
  610. *
  611. * During this preparation the array that is passed as the second parameter is filled with
  612. * <columnName> => <value> pairs, grouped by table name.
  613. *
  614. * Example:
  615. * <code>
  616. * array(
  617. * 'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...),
  618. * 'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...),
  619. * ...
  620. * )
  621. * </code>
  622. *
  623. * @param object $entity The entity for which to prepare the data.
  624. * @param bool $isInsert Whether the data to be prepared refers to an insert statement.
  625. *
  626. * @return mixed[][] The prepared data.
  627. * @psalm-return array<string, array<array-key, mixed|null>>
  628. */
  629. protected function prepareUpdateData($entity, bool $isInsert = false)
  630. {
  631. $versionField = null;
  632. $result = [];
  633. $uow = $this->em->getUnitOfWork();
  635. $versioned = $this->class->isVersioned;
  636. if ($versioned !== false) {
  637. $versionField = $this->class->versionField;
  638. }
  640. foreach ($uow->getEntityChangeSet($entity) as $field => $change) {
  641. if (isset($versionField) && $versionField === $field) {
  642. continue;
  643. }
  645. if (isset($this->class->embeddedClasses[$field])) {
  646. continue;
  647. }
  649. $newVal = $change[1];
  651. if (! isset($this->class->associationMappings[$field])) {
  652. $fieldMapping = $this->class->fieldMappings[$field];
  653. $columnName = $fieldMapping['columnName'];
  655. if (! $isInsert && isset($fieldMapping['notUpdatable'])) {
  656. continue;
  657. }
  659. if ($isInsert && isset($fieldMapping['notInsertable'])) {
  660. continue;
  661. }
  663. $this->columnTypes[$columnName] = $fieldMapping['type'];
  665. $result[$this->getOwningTable($field)][$columnName] = $newVal;
  667. continue;
  668. }
  670. $assoc = $this->class->associationMappings[$field];
  672. // Only owning side of x-1 associations can have a FK column.
  673. if (! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE)) {
  674. continue;
  675. }
  677. if ($newVal !== null) {
  678. $oid = spl_object_id($newVal);
  680. if (isset($this->queuedInserts[$oid]) || $uow->isScheduledForInsert($newVal)) {
  681. // The associated entity $newVal is not yet persisted, so we must
  682. // set $newVal = null, in order to insert a null value and schedule an
  683. // extra update on the UnitOfWork.
  684. $uow->scheduleExtraUpdate($entity, [$field => [null, $newVal]]);
  686. $newVal = null;
  687. }
  688. }
  690. $newValId = null;
  692. if ($newVal !== null) {
  693. $newValId = $uow->getEntityIdentifier($newVal);
  694. }
  696. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  697. $owningTable = $this->getOwningTable($field);
  699. foreach ($assoc['joinColumns'] as $joinColumn) {
  700. $sourceColumn = $joinColumn['name'];
  701. $targetColumn = $joinColumn['referencedColumnName'];
  702. $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  704. $this->quotedColumns[$sourceColumn] = $quotedColumn;
  705. $this->columnTypes[$sourceColumn] = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
  706. $result[$owningTable][$sourceColumn] = $newValId
  707. ? $newValId[$targetClass->getFieldForColumn($targetColumn)]
  708. : null;
  709. }
  710. }
  712. return $result;
  713. }
  715. /**
  716. * Prepares the data changeset of a managed entity for database insertion (initial INSERT).
  717. * The changeset of the entity is obtained from the currently running UnitOfWork.
  718. *
  719. * The default insert data preparation is the same as for updates.
  720. *
  721. * @see prepareUpdateData
  722. *
  723. * @param object $entity The entity for which to prepare the data.
  724. *
  725. * @return mixed[][] The prepared data for the tables to update.
  726. * @psalm-return array<string, mixed[]>
  727. */
  728. protected function prepareInsertData($entity)
  729. {
  730. return $this->prepareUpdateData($entity, true);
  731. }
  733. /**
  734. * {@inheritdoc}
  735. */
  736. public function getOwningTable($fieldName)
  737. {
  738. return $this->class->getTableName();
  739. }
  741. /**
  742. * {@inheritdoc}
  743. */
  744. public function load(array $criteria, $entity = null, $assoc = null, array $hints = [], $lockMode = null, $limit = null, ?array $orderBy = null)
  745. {
  746. $this->switchPersisterContext(null, $limit);
  748. $sql = $this->getSelectSQL($criteria, $assoc, $lockMode, $limit, null, $orderBy);
  749. [$params, $types] = $this->expandParameters($criteria);
  750. $stmt = $this->conn->executeQuery($sql, $params, $types);
  752. if ($entity !== null) {
  753. $hints[Query::HINT_REFRESH] = true;
  754. $hints[Query::HINT_REFRESH_ENTITY] = $entity;
  755. }
  757. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  758. $entities = $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, $hints);
  760. return $entities ? $entities[0] : null;
  761. }
  763. /**
  764. * {@inheritdoc}
  765. */
  766. public function loadById(array $identifier, $entity = null)
  767. {
  768. return $this->load($identifier, $entity);
  769. }
  771. /**
  772. * {@inheritdoc}
  773. */
  774. public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = [])
  775. {
  776. $foundEntity = $this->em->getUnitOfWork()->tryGetById($identifier, $assoc['targetEntity']);
  777. if ($foundEntity !== false) {
  778. return $foundEntity;
  779. }
  781. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  783. if ($assoc['isOwningSide']) {
  784. $isInverseSingleValued = $assoc['inversedBy'] && ! $targetClass->isCollectionValuedAssociation($assoc['inversedBy']);
  786. // Mark inverse side as fetched in the hints, otherwise the UoW would
  787. // try to load it in a separate query (remember: to-one inverse sides can not be lazy).
  788. $hints = [];
  790. if ($isInverseSingleValued) {
  791. $hints['fetched']['r'][$assoc['inversedBy']] = true;
  792. }
  794. $targetEntity = $this->load($identifier, null, $assoc, $hints);
  796. // Complete bidirectional association, if necessary
  797. if ($targetEntity !== null && $isInverseSingleValued) {
  798. $targetClass->reflFields[$assoc['inversedBy']]->setValue($targetEntity, $sourceEntity);
  799. }
  801. return $targetEntity;
  802. }
  804. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  805. $owningAssoc = $targetClass->getAssociationMapping($assoc['mappedBy']);
  807. $computedIdentifier = [];
  809. // TRICKY: since the association is specular source and target are flipped
  810. foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  811. if (! isset($sourceClass->fieldNames[$sourceKeyColumn])) {
  812. throw MappingException::joinColumnMustPointToMappedField(
  813. $sourceClass->name,
  814. $sourceKeyColumn
  815. );
  816. }
  818. $computedIdentifier[$targetClass->getFieldForColumn($targetKeyColumn)] =
  819. $sourceClass->reflFields[$sourceClass->fieldNames[$sourceKeyColumn]]->getValue($sourceEntity);
  820. }
  822. $targetEntity = $this->load($computedIdentifier, null, $assoc);
  824. if ($targetEntity !== null) {
  825. $targetClass->setFieldValue($targetEntity, $assoc['mappedBy'], $sourceEntity);
  826. }
  828. return $targetEntity;
  829. }
  831. /**
  832. * {@inheritdoc}
  833. */
  834. public function refresh(array $id, $entity, $lockMode = null)
  835. {
  836. $sql = $this->getSelectSQL($id, null, $lockMode);
  837. [$params, $types] = $this->expandParameters($id);
  838. $stmt = $this->conn->executeQuery($sql, $params, $types);
  840. $hydrator = $this->em->newHydrator(Query::HYDRATE_OBJECT);
  841. $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [Query::HINT_REFRESH => true]);
  842. }
  844. /**
  845. * {@inheritDoc}
  846. */
  847. public function count($criteria = [])
  848. {
  849. $sql = $this->getCountSQL($criteria);
  851. [$params, $types] = $criteria instanceof Criteria
  852. ? $this->expandCriteriaParameters($criteria)
  853. : $this->expandParameters($criteria);
  855. return (int) $this->conn->executeQuery($sql, $params, $types)->fetchOne();
  856. }
  858. /**
  859. * {@inheritdoc}
  860. */
  861. public function loadCriteria(Criteria $criteria)
  862. {
  863. $orderBy = $criteria->getOrderings();
  864. $limit = $criteria->getMaxResults();
  865. $offset = $criteria->getFirstResult();
  866. $query = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  868. [$params, $types] = $this->expandCriteriaParameters($criteria);
  870. $stmt = $this->conn->executeQuery($query, $params, $types);
  871. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  873. return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  874. }
  876. /**
  877. * {@inheritdoc}
  878. */
  879. public function expandCriteriaParameters(Criteria $criteria)
  880. {
  881. $expression = $criteria->getWhereExpression();
  882. $sqlParams = [];
  883. $sqlTypes = [];
  885. if ($expression === null) {
  886. return [$sqlParams, $sqlTypes];
  887. }
  889. $valueVisitor = new SqlValueVisitor();
  891. $valueVisitor->dispatch($expression);
  893. [, $types] = $valueVisitor->getParamsAndTypes();
  895. foreach ($types as $type) {
  896. [$field, $value, $operator] = $type;
  898. if ($value === null && ($operator === Comparison::EQ || $operator === Comparison::NEQ)) {
  899. continue;
  900. }
  902. $sqlParams = array_merge($sqlParams, $this->getValues($value));
  903. $sqlTypes = array_merge($sqlTypes, $this->getTypes($field, $value, $this->class));
  904. }
  906. return [$sqlParams, $sqlTypes];
  907. }
  909. /**
  910. * {@inheritdoc}
  911. */
  912. public function loadAll(array $criteria = [], ?array $orderBy = null, $limit = null, $offset = null)
  913. {
  914. $this->switchPersisterContext($offset, $limit);
  916. $sql = $this->getSelectSQL($criteria, null, null, $limit, $offset, $orderBy);
  917. [$params, $types] = $this->expandParameters($criteria);
  918. $stmt = $this->conn->executeQuery($sql, $params, $types);
  920. $hydrator = $this->em->newHydrator($this->currentPersisterContext->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
  922. return $hydrator->hydrateAll($stmt, $this->currentPersisterContext->rsm, [UnitOfWork::HINT_DEFEREAGERLOAD => true]);
  923. }
  925. /**
  926. * {@inheritdoc}
  927. */
  928. public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  929. {
  930. $this->switchPersisterContext($offset, $limit);
  932. $stmt = $this->getManyToManyStatement($assoc, $sourceEntity, $offset, $limit);
  934. return $this->loadArrayFromResult($assoc, $stmt);
  935. }
  937. /**
  938. * Loads an array of entities from a given DBAL statement.
  939. *
  940. * @param mixed[] $assoc
  941. *
  942. * @return mixed[]
  943. */
  944. private function loadArrayFromResult(array $assoc, Result $stmt): array
  945. {
  946. $rsm = $this->currentPersisterContext->rsm;
  947. $hints = [UnitOfWork::HINT_DEFEREAGERLOAD => true];
  949. if (isset($assoc['indexBy'])) {
  950. $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  951. $rsm->addIndexBy('r', $assoc['indexBy']);
  952. }
  954. return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  955. }
  957. /**
  958. * Hydrates a collection from a given DBAL statement.
  959. *
  960. * @param mixed[] $assoc
  961. *
  962. * @return mixed[]
  963. */
  964. private function loadCollectionFromStatement(
  965. array $assoc,
  966. Result $stmt,
  967. PersistentCollection $coll
  968. ): array {
  969. $rsm = $this->currentPersisterContext->rsm;
  970. $hints = [
  971. UnitOfWork::HINT_DEFEREAGERLOAD => true,
  972. 'collection' => $coll,
  973. ];
  975. if (isset($assoc['indexBy'])) {
  976. $rsm = clone $this->currentPersisterContext->rsm; // this is necessary because the "default rsm" should be changed.
  977. $rsm->addIndexBy('r', $assoc['indexBy']);
  978. }
  980. return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $rsm, $hints);
  981. }
  983. /**
  984. * {@inheritdoc}
  985. */
  986. public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  987. {
  988. $stmt = $this->getManyToManyStatement($assoc, $sourceEntity);
  990. return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  991. }
  993. /**
  994. * @param object $sourceEntity
  995. * @psalm-param array<string, mixed> $assoc
  996. *
  997. * @return Result
  998. *
  999. * @throws MappingException
  1000. */
  1001. private function getManyToManyStatement(
  1002. array $assoc,
  1003. $sourceEntity,
  1004. ?int $offset = null,
  1005. ?int $limit = null
  1006. ) {
  1007. $this->switchPersisterContext($offset, $limit);
  1009. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1010. $class = $sourceClass;
  1011. $association = $assoc;
  1012. $criteria = [];
  1013. $parameters = [];
  1015. if (! $assoc['isOwningSide']) {
  1016. $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1017. $association = $class->associationMappings[$assoc['mappedBy']];
  1018. }
  1020. $joinColumns = $assoc['isOwningSide']
  1021. ? $association['joinTable']['joinColumns']
  1022. : $association['joinTable']['inverseJoinColumns'];
  1024. $quotedJoinTable = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1026. foreach ($joinColumns as $joinColumn) {
  1027. $sourceKeyColumn = $joinColumn['referencedColumnName'];
  1028. $quotedKeyColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1030. switch (true) {
  1031. case $sourceClass->containsForeignIdentifier:
  1032. $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1033. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1035. if (isset($sourceClass->associationMappings[$field])) {
  1036. $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1037. $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1038. }
  1040. break;
  1042. case isset($sourceClass->fieldNames[$sourceKeyColumn]):
  1043. $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1044. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1046. break;
  1048. default:
  1049. throw MappingException::joinColumnMustPointToMappedField(
  1050. $sourceClass->name,
  1051. $sourceKeyColumn
  1052. );
  1053. }
  1055. $criteria[$quotedJoinTable . '.' . $quotedKeyColumn] = $value;
  1056. $parameters[] = [
  1057. 'value' => $value,
  1058. 'field' => $field,
  1059. 'class' => $sourceClass,
  1060. ];
  1061. }
  1063. $sql = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1064. [$params, $types] = $this->expandToManyParameters($parameters);
  1066. return $this->conn->executeQuery($sql, $params, $types);
  1067. }
  1069. /**
  1070. * {@inheritdoc}
  1071. */
  1072. public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, ?array $orderBy = null)
  1073. {
  1074. $this->switchPersisterContext($offset, $limit);
  1076. $lockSql = '';
  1077. $joinSql = '';
  1078. $orderBySql = '';
  1080. if ($assoc !== null && $assoc['type'] === ClassMetadata::MANY_TO_MANY) {
  1081. $joinSql = $this->getSelectManyToManyJoinSQL($assoc);
  1082. }
  1084. if (isset($assoc['orderBy'])) {
  1085. $orderBy = $assoc['orderBy'];
  1086. }
  1088. if ($orderBy) {
  1089. $orderBySql = $this->getOrderBySQL($orderBy, $this->getSQLTableAlias($this->class->name));
  1090. }
  1092. $conditionSql = $criteria instanceof Criteria
  1093. ? $this->getSelectConditionCriteriaSQL($criteria)
  1094. : $this->getSelectConditionSQL($criteria, $assoc);
  1096. switch ($lockMode) {
  1097. case LockMode::PESSIMISTIC_READ:
  1098. $lockSql = ' ' . $this->platform->getReadLockSQL();
  1099. break;
  1101. case LockMode::PESSIMISTIC_WRITE:
  1102. $lockSql = ' ' . $this->platform->getWriteLockSQL();
  1103. break;
  1104. }
  1106. $columnList = $this->getSelectColumnsSQL();
  1107. $tableAlias = $this->getSQLTableAlias($this->class->name);
  1108. $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1109. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1111. if ($filterSql !== '') {
  1112. $conditionSql = $conditionSql
  1113. ? $conditionSql . ' AND ' . $filterSql
  1114. : $filterSql;
  1115. }
  1117. $select = 'SELECT ' . $columnList;
  1118. $from = ' FROM ' . $tableName . ' ' . $tableAlias;
  1119. $join = $this->currentPersisterContext->selectJoinSql . $joinSql;
  1120. $where = ($conditionSql ? ' WHERE ' . $conditionSql : '');
  1121. $lock = $this->platform->appendLockHint($from, $lockMode ?? LockMode::NONE);
  1122. $query = $select
  1123. . $lock
  1124. . $join
  1125. . $where
  1126. . $orderBySql;
  1128. return $this->platform->modifyLimitQuery($query, $limit, $offset ?? 0) . $lockSql;
  1129. }
  1131. /**
  1132. * {@inheritDoc}
  1133. */
  1134. public function getCountSQL($criteria = [])
  1135. {
  1136. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1137. $tableAlias = $this->getSQLTableAlias($this->class->name);
  1139. $conditionSql = $criteria instanceof Criteria
  1140. ? $this->getSelectConditionCriteriaSQL($criteria)
  1141. : $this->getSelectConditionSQL($criteria);
  1143. $filterSql = $this->generateFilterConditionSQL($this->class, $tableAlias);
  1145. if ($filterSql !== '') {
  1146. $conditionSql = $conditionSql
  1147. ? $conditionSql . ' AND ' . $filterSql
  1148. : $filterSql;
  1149. }
  1151. return 'SELECT COUNT(*) '
  1152. . 'FROM ' . $tableName . ' ' . $tableAlias
  1153. . (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
  1154. }
  1156. /**
  1157. * Gets the ORDER BY SQL snippet for ordered collections.
  1158. *
  1159. * @psalm-param array<string, string> $orderBy
  1160. *
  1161. * @throws InvalidOrientation
  1162. * @throws InvalidFindByCall
  1163. * @throws UnrecognizedField
  1164. */
  1165. final protected function getOrderBySQL(array $orderBy, string $baseTableAlias): string
  1166. {
  1167. $orderByList = [];
  1169. foreach ($orderBy as $fieldName => $orientation) {
  1170. $orientation = strtoupper(trim($orientation));
  1172. if ($orientation !== 'ASC' && $orientation !== 'DESC') {
  1173. throw InvalidOrientation::fromClassNameAndField($this->class->name, $fieldName);
  1174. }
  1176. if (isset($this->class->fieldMappings[$fieldName])) {
  1177. $tableAlias = isset($this->class->fieldMappings[$fieldName]['inherited'])
  1178. ? $this->getSQLTableAlias($this->class->fieldMappings[$fieldName]['inherited'])
  1179. : $baseTableAlias;
  1181. $columnName = $this->quoteStrategy->getColumnName($fieldName, $this->class, $this->platform);
  1182. $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1184. continue;
  1185. }
  1187. if (isset($this->class->associationMappings[$fieldName])) {
  1188. if (! $this->class->associationMappings[$fieldName]['isOwningSide']) {
  1189. throw InvalidFindByCall::fromInverseSideUsage($this->class->name, $fieldName);
  1190. }
  1192. $tableAlias = isset($this->class->associationMappings[$fieldName]['inherited'])
  1193. ? $this->getSQLTableAlias($this->class->associationMappings[$fieldName]['inherited'])
  1194. : $baseTableAlias;
  1196. foreach ($this->class->associationMappings[$fieldName]['joinColumns'] as $joinColumn) {
  1197. $columnName = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1198. $orderByList[] = $tableAlias . '.' . $columnName . ' ' . $orientation;
  1199. }
  1201. continue;
  1202. }
  1204. throw UnrecognizedField::byFullyQualifiedName($this->class->name, $fieldName);
  1205. }
  1207. return ' ORDER BY ' . implode(', ', $orderByList);
  1208. }
  1210. /**
  1211. * Gets the SQL fragment with the list of columns to select when querying for
  1212. * an entity in this persister.
  1213. *
  1214. * Subclasses should override this method to alter or change the select column
  1215. * list SQL fragment. Note that in the implementation of BasicEntityPersister
  1216. * the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}.
  1217. * Subclasses may or may not do the same.
  1218. *
  1219. * @return string The SQL fragment.
  1220. */
  1221. protected function getSelectColumnsSQL()
  1222. {
  1223. if ($this->currentPersisterContext->selectColumnListSql !== null) {
  1224. return $this->currentPersisterContext->selectColumnListSql;
  1225. }
  1227. $columnList = [];
  1228. $this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r'); // r for root
  1230. // Add regular columns to select list
  1231. foreach ($this->class->fieldNames as $field) {
  1232. $columnList[] = $this->getSelectColumnSQL($field, $this->class);
  1233. }
  1235. $this->currentPersisterContext->selectJoinSql = '';
  1236. $eagerAliasCounter = 0;
  1238. foreach ($this->class->associationMappings as $assocField => $assoc) {
  1239. $assocColumnSQL = $this->getSelectColumnAssociationSQL($assocField, $assoc, $this->class);
  1241. if ($assocColumnSQL) {
  1242. $columnList[] = $assocColumnSQL;
  1243. }
  1245. $isAssocToOneInverseSide = $assoc['type'] & ClassMetadata::TO_ONE && ! $assoc['isOwningSide'];
  1246. $isAssocFromOneEager = $assoc['type'] !== ClassMetadata::MANY_TO_MANY && $assoc['fetch'] === ClassMetadata::FETCH_EAGER;
  1248. if (! ($isAssocFromOneEager || $isAssocToOneInverseSide)) {
  1249. continue;
  1250. }
  1252. if ((($assoc['type'] & ClassMetadata::TO_MANY) > 0) && $this->currentPersisterContext->handlesLimits) {
  1253. continue;
  1254. }
  1256. $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1258. if ($eagerEntity->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  1259. continue; // now this is why you shouldn't use inheritance
  1260. }
  1262. $assocAlias = 'e' . ($eagerAliasCounter++);
  1263. $this->currentPersisterContext->rsm->addJoinedEntityResult($assoc['targetEntity'], $assocAlias, 'r', $assocField);
  1265. foreach ($eagerEntity->fieldNames as $field) {
  1266. $columnList[] = $this->getSelectColumnSQL($field, $eagerEntity, $assocAlias);
  1267. }
  1269. foreach ($eagerEntity->associationMappings as $eagerAssocField => $eagerAssoc) {
  1270. $eagerAssocColumnSQL = $this->getSelectColumnAssociationSQL(
  1271. $eagerAssocField,
  1272. $eagerAssoc,
  1273. $eagerEntity,
  1274. $assocAlias
  1275. );
  1277. if ($eagerAssocColumnSQL) {
  1278. $columnList[] = $eagerAssocColumnSQL;
  1279. }
  1280. }
  1282. $association = $assoc;
  1283. $joinCondition = [];
  1285. if (isset($assoc['indexBy'])) {
  1286. $this->currentPersisterContext->rsm->addIndexBy($assocAlias, $assoc['indexBy']);
  1287. }
  1289. if (! $assoc['isOwningSide']) {
  1290. $eagerEntity = $this->em->getClassMetadata($assoc['targetEntity']);
  1291. $association = $eagerEntity->getAssociationMapping($assoc['mappedBy']);
  1292. }
  1294. $joinTableAlias = $this->getSQLTableAlias($eagerEntity->name, $assocAlias);
  1295. $joinTableName = $this->quoteStrategy->getTableName($eagerEntity, $this->platform);
  1297. if ($assoc['isOwningSide']) {
  1298. $tableAlias = $this->getSQLTableAlias($association['targetEntity'], $assocAlias);
  1299. $this->currentPersisterContext->selectJoinSql .= ' ' . $this->getJoinSQLForJoinColumns($association['joinColumns']);
  1301. foreach ($association['joinColumns'] as $joinColumn) {
  1302. $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1303. $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1304. $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'])
  1305. . '.' . $sourceCol . ' = ' . $tableAlias . '.' . $targetCol;
  1306. }
  1308. // Add filter SQL
  1309. $filterSql = $this->generateFilterConditionSQL($eagerEntity, $tableAlias);
  1310. if ($filterSql) {
  1311. $joinCondition[] = $filterSql;
  1312. }
  1313. } else {
  1314. $this->currentPersisterContext->selectJoinSql .= ' LEFT JOIN';
  1316. foreach ($association['joinColumns'] as $joinColumn) {
  1317. $sourceCol = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1318. $targetCol = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1320. $joinCondition[] = $this->getSQLTableAlias($association['sourceEntity'], $assocAlias) . '.' . $sourceCol . ' = '
  1321. . $this->getSQLTableAlias($association['targetEntity']) . '.' . $targetCol;
  1322. }
  1323. }
  1325. $this->currentPersisterContext->selectJoinSql .= ' ' . $joinTableName . ' ' . $joinTableAlias . ' ON ';
  1326. $this->currentPersisterContext->selectJoinSql .= implode(' AND ', $joinCondition);
  1327. }
  1329. $this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
  1331. return $this->currentPersisterContext->selectColumnListSql;
  1332. }
  1334. /**
  1335. * Gets the SQL join fragment used when selecting entities from an association.
  1336. *
  1337. * @param string $field
  1338. * @param mixed[] $assoc
  1339. * @param string $alias
  1340. *
  1341. * @return string
  1342. */
  1343. protected function getSelectColumnAssociationSQL($field, $assoc, ClassMetadata $class, $alias = 'r')
  1344. {
  1345. if (! ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE)) {
  1346. return '';
  1347. }
  1349. $columnList = [];
  1350. $targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
  1351. $isIdentifier = isset($assoc['id']) && $assoc['id'] === true;
  1352. $sqlTableAlias = $this->getSQLTableAlias($class->name, ($alias === 'r' ? '' : $alias));
  1354. foreach ($assoc['joinColumns'] as $joinColumn) {
  1355. $quotedColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1356. $resultColumnName = $this->getSQLColumnAlias($joinColumn['name']);
  1357. $type = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  1359. $this->currentPersisterContext->rsm->addMetaResult($alias, $resultColumnName, $joinColumn['name'], $isIdentifier, $type);
  1361. $columnList[] = sprintf('%s.%s AS %s', $sqlTableAlias, $quotedColumn, $resultColumnName);
  1362. }
  1364. return implode(', ', $columnList);
  1365. }
  1367. /**
  1368. * Gets the SQL join fragment used when selecting entities from a
  1369. * many-to-many association.
  1370. *
  1371. * @psalm-param array<string, mixed> $manyToMany
  1372. *
  1373. * @return string
  1374. */
  1375. protected function getSelectManyToManyJoinSQL(array $manyToMany)
  1376. {
  1377. $conditions = [];
  1378. $association = $manyToMany;
  1379. $sourceTableAlias = $this->getSQLTableAlias($this->class->name);
  1381. if (! $manyToMany['isOwningSide']) {
  1382. $targetEntity = $this->em->getClassMetadata($manyToMany['targetEntity']);
  1383. $association = $targetEntity->associationMappings[$manyToMany['mappedBy']];
  1384. }
  1386. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $this->class, $this->platform);
  1387. $joinColumns = $manyToMany['isOwningSide']
  1388. ? $association['joinTable']['inverseJoinColumns']
  1389. : $association['joinTable']['joinColumns'];
  1391. foreach ($joinColumns as $joinColumn) {
  1392. $quotedSourceColumn = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1393. $quotedTargetColumn = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $this->class, $this->platform);
  1394. $conditions[] = $sourceTableAlias . '.' . $quotedTargetColumn . ' = ' . $joinTableName . '.' . $quotedSourceColumn;
  1395. }
  1397. return ' INNER JOIN ' . $joinTableName . ' ON ' . implode(' AND ', $conditions);
  1398. }
  1400. /**
  1401. * {@inheritdoc}
  1402. */
  1403. public function getInsertSQL()
  1404. {
  1405. if ($this->insertSql !== null) {
  1406. return $this->insertSql;
  1407. }
  1409. $columns = $this->getInsertColumnList();
  1410. $tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
  1412. if (empty($columns)) {
  1413. $identityColumn = $this->quoteStrategy->getColumnName($this->class->identifier[0], $this->class, $this->platform);
  1414. $this->insertSql = $this->platform->getEmptyIdentityInsertSQL($tableName, $identityColumn);
  1416. return $this->insertSql;
  1417. }
  1419. $values = [];
  1420. $columns = array_unique($columns);
  1422. foreach ($columns as $column) {
  1423. $placeholder = '?';
  1425. if (
  1426. isset($this->class->fieldNames[$column])
  1427. && isset($this->columnTypes[$this->class->fieldNames[$column]])
  1428. && isset($this->class->fieldMappings[$this->class->fieldNames[$column]]['requireSQLConversion'])
  1429. ) {
  1430. $type = Type::getType($this->columnTypes[$this->class->fieldNames[$column]]);
  1431. $placeholder = $type->convertToDatabaseValueSQL('?', $this->platform);
  1432. }
  1434. $values[] = $placeholder;
  1435. }
  1437. $columns = implode(', ', $columns);
  1438. $values = implode(', ', $values);
  1440. $this->insertSql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tableName, $columns, $values);
  1442. return $this->insertSql;
  1443. }
  1445. /**
  1446. * Gets the list of columns to put in the INSERT SQL statement.
  1447. *
  1448. * Subclasses should override this method to alter or change the list of
  1449. * columns placed in the INSERT statements used by the persister.
  1450. *
  1451. * @return string[] The list of columns.
  1452. * @psalm-return list<string>
  1453. */
  1454. protected function getInsertColumnList()
  1455. {
  1456. $columns = [];
  1458. foreach ($this->class->reflFields as $name => $field) {
  1459. if ($this->class->isVersioned && $this->class->versionField === $name) {
  1460. continue;
  1461. }
  1463. if (isset($this->class->embeddedClasses[$name])) {
  1464. continue;
  1465. }
  1467. if (isset($this->class->associationMappings[$name])) {
  1468. $assoc = $this->class->associationMappings[$name];
  1470. if ($assoc['isOwningSide'] && $assoc['type'] & ClassMetadata::TO_ONE) {
  1471. foreach ($assoc['joinColumns'] as $joinColumn) {
  1472. $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1473. }
  1474. }
  1476. continue;
  1477. }
  1479. if (! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] !== $name) {
  1480. if (isset($this->class->fieldMappings[$name]['notInsertable'])) {
  1481. continue;
  1482. }
  1484. $columns[] = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
  1485. $this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
  1486. }
  1487. }
  1489. return $columns;
  1490. }
  1492. /**
  1493. * Gets the SQL snippet of a qualified column name for the given field name.
  1494. *
  1495. * @param string $field The field name.
  1496. * @param ClassMetadata $class The class that declares this field. The table this class is
  1497. * mapped to must own the column for the given field.
  1498. * @param string $alias
  1499. *
  1500. * @return string
  1501. */
  1502. protected function getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r')
  1503. {
  1504. $root = $alias === 'r' ? '' : $alias;
  1505. $tableAlias = $this->getSQLTableAlias($class->name, $root);
  1506. $fieldMapping = $class->fieldMappings[$field];
  1507. $sql = sprintf('%s.%s', $tableAlias, $this->quoteStrategy->getColumnName($field, $class, $this->platform));
  1508. $columnAlias = $this->getSQLColumnAlias($fieldMapping['columnName']);
  1510. $this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field);
  1511. if (! empty($fieldMapping['enumType'])) {
  1512. $this->currentPersisterContext->rsm->addEnumResult($columnAlias, $fieldMapping['enumType']);
  1513. }
  1515. if (isset($fieldMapping['requireSQLConversion'])) {
  1516. $type = Type::getType($fieldMapping['type']);
  1517. $sql = $type->convertToPHPValueSQL($sql, $this->platform);
  1518. }
  1520. return $sql . ' AS ' . $columnAlias;
  1521. }
  1523. /**
  1524. * Gets the SQL table alias for the given class name.
  1525. *
  1526. * @param string $className
  1527. * @param string $assocName
  1528. *
  1529. * @return string The SQL table alias.
  1530. *
  1531. * @todo Reconsider. Binding table aliases to class names is not such a good idea.
  1532. */
  1533. protected function getSQLTableAlias($className, $assocName = '')
  1534. {
  1535. if ($assocName) {
  1536. $className .= '#' . $assocName;
  1537. }
  1539. if (isset($this->currentPersisterContext->sqlTableAliases[$className])) {
  1540. return $this->currentPersisterContext->sqlTableAliases[$className];
  1541. }
  1543. $tableAlias = 't' . $this->currentPersisterContext->sqlAliasCounter++;
  1545. $this->currentPersisterContext->sqlTableAliases[$className] = $tableAlias;
  1547. return $tableAlias;
  1548. }
  1550. /**
  1551. * {@inheritdoc}
  1552. */
  1553. public function lock(array $criteria, $lockMode)
  1554. {
  1555. $lockSql = '';
  1556. $conditionSql = $this->getSelectConditionSQL($criteria);
  1558. switch ($lockMode) {
  1559. case LockMode::PESSIMISTIC_READ:
  1560. $lockSql = $this->platform->getReadLockSQL();
  1562. break;
  1563. case LockMode::PESSIMISTIC_WRITE:
  1564. $lockSql = $this->platform->getWriteLockSQL();
  1565. break;
  1566. }
  1568. $lock = $this->getLockTablesSql($lockMode);
  1569. $where = ($conditionSql ? ' WHERE ' . $conditionSql : '') . ' ';
  1570. $sql = 'SELECT 1 '
  1571. . $lock
  1572. . $where
  1573. . $lockSql;
  1575. [$params, $types] = $this->expandParameters($criteria);
  1577. $this->conn->executeQuery($sql, $params, $types);
  1578. }
  1580. /**
  1581. * Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.
  1582. *
  1583. * @param int|null $lockMode One of the Doctrine\DBAL\LockMode::* constants.
  1584. * @psalm-param LockMode::*|null $lockMode
  1585. *
  1586. * @return string
  1587. */
  1588. protected function getLockTablesSql($lockMode)
  1589. {
  1590. if ($lockMode === null) {
  1591. Deprecation::trigger(
  1592. 'doctrine/orm',
  1593. 'https://github.com/doctrine/orm/pull/9466',
  1594. 'Passing null as argument to %s is deprecated, pass LockMode::NONE instead.',
  1595. __METHOD__
  1596. );
  1598. $lockMode = LockMode::NONE;
  1599. }
  1601. return $this->platform->appendLockHint(
  1602. 'FROM '
  1603. . $this->quoteStrategy->getTableName($this->class, $this->platform) . ' '
  1604. . $this->getSQLTableAlias($this->class->name),
  1605. $lockMode
  1606. );
  1607. }
  1609. /**
  1610. * Gets the Select Where Condition from a Criteria object.
  1611. *
  1612. * @return string
  1613. */
  1614. protected function getSelectConditionCriteriaSQL(Criteria $criteria)
  1615. {
  1616. $expression = $criteria->getWhereExpression();
  1618. if ($expression === null) {
  1619. return '';
  1620. }
  1622. $visitor = new SqlExpressionVisitor($this, $this->class);
  1624. return $visitor->dispatch($expression);
  1625. }
  1627. /**
  1628. * {@inheritdoc}
  1629. */
  1630. public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null)
  1631. {
  1632. $selectedColumns = [];
  1633. $columns = $this->getSelectConditionStatementColumnSQL($field, $assoc);
  1635. if (count($columns) > 1 && $comparison === Comparison::IN) {
  1636. /*
  1637. * @todo try to support multi-column IN expressions.
  1638. * Example: (col1, col2) IN (('val1A', 'val2A'), ('val1B', 'val2B'))
  1639. */
  1640. throw CantUseInOperatorOnCompositeKeys::create();
  1641. }
  1643. foreach ($columns as $column) {
  1644. $placeholder = '?';
  1646. if (isset($this->class->fieldMappings[$field]['requireSQLConversion'])) {
  1647. $type = Type::getType($this->class->fieldMappings[$field]['type']);
  1648. $placeholder = $type->convertToDatabaseValueSQL($placeholder, $this->platform);
  1649. }
  1651. if ($comparison !== null) {
  1652. // special case null value handling
  1653. if (($comparison === Comparison::EQ || $comparison === Comparison::IS) && $value === null) {
  1654. $selectedColumns[] = $column . ' IS NULL';
  1656. continue;
  1657. }
  1659. if ($comparison === Comparison::NEQ && $value === null) {
  1660. $selectedColumns[] = $column . ' IS NOT NULL';
  1662. continue;
  1663. }
  1665. $selectedColumns[] = $column . ' ' . sprintf(self::$comparisonMap[$comparison], $placeholder);
  1667. continue;
  1668. }
  1670. if (is_array($value)) {
  1671. $in = sprintf('%s IN (%s)', $column, $placeholder);
  1673. if (array_search(null, $value, true) !== false) {
  1674. $selectedColumns[] = sprintf('(%s OR %s IS NULL)', $in, $column);
  1676. continue;
  1677. }
  1679. $selectedColumns[] = $in;
  1681. continue;
  1682. }
  1684. if ($value === null) {
  1685. $selectedColumns[] = sprintf('%s IS NULL', $column);
  1687. continue;
  1688. }
  1690. $selectedColumns[] = sprintf('%s = %s', $column, $placeholder);
  1691. }
  1693. return implode(' AND ', $selectedColumns);
  1694. }
  1696. /**
  1697. * Builds the left-hand-side of a where condition statement.
  1698. *
  1699. * @psalm-param array<string, mixed>|null $assoc
  1700. *
  1701. * @return string[]
  1702. * @psalm-return list<string>
  1703. *
  1704. * @throws InvalidFindByCall
  1705. * @throws UnrecognizedField
  1706. */
  1707. private function getSelectConditionStatementColumnSQL(
  1708. string $field,
  1709. ?array $assoc = null
  1710. ): array {
  1711. if (isset($this->class->fieldMappings[$field])) {
  1712. $className = $this->class->fieldMappings[$field]['inherited'] ?? $this->class->name;
  1714. return [$this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getColumnName($field, $this->class, $this->platform)];
  1715. }
  1717. if (isset($this->class->associationMappings[$field])) {
  1718. $association = $this->class->associationMappings[$field];
  1719. // Many-To-Many requires join table check for joinColumn
  1720. $columns = [];
  1721. $class = $this->class;
  1723. if ($association['type'] === ClassMetadata::MANY_TO_MANY) {
  1724. if (! $association['isOwningSide']) {
  1725. $association = $assoc;
  1726. }
  1728. $joinTableName = $this->quoteStrategy->getJoinTableName($association, $class, $this->platform);
  1729. $joinColumns = $assoc['isOwningSide']
  1730. ? $association['joinTable']['joinColumns']
  1731. : $association['joinTable']['inverseJoinColumns'];
  1733. foreach ($joinColumns as $joinColumn) {
  1734. $columns[] = $joinTableName . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  1735. }
  1736. } else {
  1737. if (! $association['isOwningSide']) {
  1738. throw InvalidFindByCall::fromInverseSideUsage(
  1739. $this->class->name,
  1740. $field
  1741. );
  1742. }
  1744. $className = $association['inherited'] ?? $this->class->name;
  1746. foreach ($association['joinColumns'] as $joinColumn) {
  1747. $columns[] = $this->getSQLTableAlias($className) . '.' . $this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform);
  1748. }
  1749. }
  1751. return $columns;
  1752. }
  1754. if ($assoc !== null && ! str_contains($field, ' ') && ! str_contains($field, '(')) {
  1755. // very careless developers could potentially open up this normally hidden api for userland attacks,
  1756. // therefore checking for spaces and function calls which are not allowed.
  1758. // found a join column condition, not really a "field"
  1759. return [$field];
  1760. }
  1762. throw UnrecognizedField::byFullyQualifiedName($this->class->name, $field);
  1763. }
  1765. /**
  1766. * Gets the conditional SQL fragment used in the WHERE clause when selecting
  1767. * entities in this persister.
  1768. *
  1769. * Subclasses are supposed to override this method if they intend to change
  1770. * or alter the criteria by which entities are selected.
  1771. *
  1772. * @param mixed[]|null $assoc
  1773. * @psalm-param array<string, mixed> $criteria
  1774. * @psalm-param array<string, mixed>|null $assoc
  1775. *
  1776. * @return string
  1777. */
  1778. protected function getSelectConditionSQL(array $criteria, $assoc = null)
  1779. {
  1780. $conditions = [];
  1782. foreach ($criteria as $field => $value) {
  1783. $conditions[] = $this->getSelectConditionStatementSQL($field, $value, $assoc);
  1784. }
  1786. return implode(' AND ', $conditions);
  1787. }
  1789. /**
  1790. * {@inheritdoc}
  1791. */
  1792. public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null)
  1793. {
  1794. $this->switchPersisterContext($offset, $limit);
  1796. $stmt = $this->getOneToManyStatement($assoc, $sourceEntity, $offset, $limit);
  1798. return $this->loadArrayFromResult($assoc, $stmt);
  1799. }
  1801. /**
  1802. * {@inheritdoc}
  1803. */
  1804. public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection)
  1805. {
  1806. $stmt = $this->getOneToManyStatement($assoc, $sourceEntity);
  1808. return $this->loadCollectionFromStatement($assoc, $stmt, $collection);
  1809. }
  1811. /**
  1812. * Builds criteria and execute SQL statement to fetch the one to many entities from.
  1813. *
  1814. * @param object $sourceEntity
  1815. * @psalm-param array<string, mixed> $assoc
  1816. */
  1817. private function getOneToManyStatement(
  1818. array $assoc,
  1819. $sourceEntity,
  1820. ?int $offset = null,
  1821. ?int $limit = null
  1822. ): Result {
  1823. $this->switchPersisterContext($offset, $limit);
  1825. $criteria = [];
  1826. $parameters = [];
  1827. $owningAssoc = $this->class->associationMappings[$assoc['mappedBy']];
  1828. $sourceClass = $this->em->getClassMetadata($assoc['sourceEntity']);
  1829. $tableAlias = $this->getSQLTableAlias($owningAssoc['inherited'] ?? $this->class->name);
  1831. foreach ($owningAssoc['targetToSourceKeyColumns'] as $sourceKeyColumn => $targetKeyColumn) {
  1832. if ($sourceClass->containsForeignIdentifier) {
  1833. $field = $sourceClass->getFieldForColumn($sourceKeyColumn);
  1834. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1836. if (isset($sourceClass->associationMappings[$field])) {
  1837. $value = $this->em->getUnitOfWork()->getEntityIdentifier($value);
  1838. $value = $value[$this->em->getClassMetadata($sourceClass->associationMappings[$field]['targetEntity'])->identifier[0]];
  1839. }
  1841. $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1842. $parameters[] = [
  1843. 'value' => $value,
  1844. 'field' => $field,
  1845. 'class' => $sourceClass,
  1846. ];
  1848. continue;
  1849. }
  1851. $field = $sourceClass->fieldNames[$sourceKeyColumn];
  1852. $value = $sourceClass->reflFields[$field]->getValue($sourceEntity);
  1854. $criteria[$tableAlias . '.' . $targetKeyColumn] = $value;
  1855. $parameters[] = [
  1856. 'value' => $value,
  1857. 'field' => $field,
  1858. 'class' => $sourceClass,
  1859. ];
  1860. }
  1862. $sql = $this->getSelectSQL($criteria, $assoc, null, $limit, $offset);
  1863. [$params, $types] = $this->expandToManyParameters($parameters);
  1865. return $this->conn->executeQuery($sql, $params, $types);
  1866. }
  1868. /**
  1869. * {@inheritdoc}
  1870. */
  1871. public function expandParameters($criteria)
  1872. {
  1873. $params = [];
  1874. $types = [];
  1876. foreach ($criteria as $field => $value) {
  1877. if ($value === null) {
  1878. continue; // skip null values.
  1879. }
  1881. $types = array_merge($types, $this->getTypes($field, $value, $this->class));
  1882. $params = array_merge($params, $this->getValues($value));
  1883. }
  1885. return [$params, $types];
  1886. }
  1888. /**
  1889. * Expands the parameters from the given criteria and use the correct binding types if found,
  1890. * specialized for OneToMany or ManyToMany associations.
  1891. *
  1892. * @param mixed[][] $criteria an array of arrays containing following:
  1893. * - field to which each criterion will be bound
  1894. * - value to be bound
  1895. * - class to which the field belongs to
  1896. *
  1897. * @return mixed[][]
  1898. * @psalm-return array{0: array, 1: list<int|string|null>}
  1899. */
  1900. private function expandToManyParameters(array $criteria): array
  1901. {
  1902. $params = [];
  1903. $types = [];
  1905. foreach ($criteria as $criterion) {
  1906. if ($criterion['value'] === null) {
  1907. continue; // skip null values.
  1908. }
  1910. $types = array_merge($types, $this->getTypes($criterion['field'], $criterion['value'], $criterion['class']));
  1911. $params = array_merge($params, $this->getValues($criterion['value']));
  1912. }
  1914. return [$params, $types];
  1915. }
  1917. /**
  1918. * Infers field types to be used by parameter type casting.
  1919. *
  1920. * @param mixed $value
  1921. *
  1922. * @return int[]|null[]|string[]
  1923. * @psalm-return list<int|string|null>
  1924. *
  1925. * @throws QueryException
  1926. */
  1927. private function getTypes(string $field, $value, ClassMetadata $class): array
  1928. {
  1929. $types = [];
  1931. switch (true) {
  1932. case isset($class->fieldMappings[$field]):
  1933. $types = array_merge($types, [$class->fieldMappings[$field]['type']]);
  1934. break;
  1936. case isset($class->associationMappings[$field]):
  1937. $assoc = $class->associationMappings[$field];
  1938. $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1940. if (! $assoc['isOwningSide']) {
  1941. $assoc = $class->associationMappings[$assoc['mappedBy']];
  1942. $class = $this->em->getClassMetadata($assoc['targetEntity']);
  1943. }
  1945. $columns = $assoc['type'] === ClassMetadata::MANY_TO_MANY
  1946. ? $assoc['relationToTargetKeyColumns']
  1947. : $assoc['sourceToTargetKeyColumns'];
  1949. foreach ($columns as $column) {
  1950. $types[] = PersisterHelper::getTypeOfColumn($column, $class, $this->em);
  1951. }
  1953. break;
  1955. default:
  1956. $types[] = null;
  1957. break;
  1958. }
  1960. if (is_array($value)) {
  1961. return array_map(static function ($type) {
  1962. $type = Type::getType($type);
  1964. return $type->getBindingType() + Connection::ARRAY_PARAM_OFFSET;
  1965. }, $types);
  1966. }
  1968. return $types;
  1969. }
  1971. /**
  1972. * Retrieves the parameters that identifies a value.
  1973. *
  1974. * @param mixed $value
  1975. *
  1976. * @return mixed[]
  1977. */
  1978. private function getValues($value): array
  1979. {
  1980. if (is_array($value)) {
  1981. $newValue = [];
  1983. foreach ($value as $itemValue) {
  1984. $newValue = array_merge($newValue, $this->getValues($itemValue));
  1985. }
  1987. return [$newValue];
  1988. }
  1990. return $this->getIndividualValue($value);
  1991. }
  1993. /**
  1994. * Retrieves an individual parameter value.
  1995. *
  1996. * @param mixed $value
  1997. *
  1998. * @psalm-return list<mixed>
  1999. */
  2000. private function getIndividualValue($value): array
  2001. {
  2002. if (! is_object($value)) {
  2003. return [$value];
  2004. }
  2006. if ($value instanceof BackedEnum) {
  2007. return [$value->value];
  2008. }
  2010. $valueClass = ClassUtils::getClass($value);
  2012. if ($this->em->getMetadataFactory()->isTransient($valueClass)) {
  2013. return [$value];
  2014. }
  2016. $class = $this->em->getClassMetadata($valueClass);
  2018. if ($class->isIdentifierComposite) {
  2019. $newValue = [];
  2021. foreach ($class->getIdentifierValues($value) as $innerValue) {
  2022. $newValue = array_merge($newValue, $this->getValues($innerValue));
  2023. }
  2025. return $newValue;
  2026. }
  2028. return [$this->em->getUnitOfWork()->getSingleIdentifierValue($value)];
  2029. }
  2031. /**
  2032. * {@inheritdoc}
  2033. */
  2034. public function exists($entity, ?Criteria $extraConditions = null)
  2035. {
  2036. $criteria = $this->class->getIdentifierValues($entity);
  2038. if (! $criteria) {
  2039. return false;
  2040. }
  2042. $alias = $this->getSQLTableAlias($this->class->name);
  2044. $sql = 'SELECT 1 '
  2045. . $this->getLockTablesSql(LockMode::NONE)
  2046. . ' WHERE ' . $this->getSelectConditionSQL($criteria);
  2048. [$params, $types] = $this->expandParameters($criteria);
  2050. if ($extraConditions !== null) {
  2051. $sql .= ' AND ' . $this->getSelectConditionCriteriaSQL($extraConditions);
  2052. [$criteriaParams, $criteriaTypes] = $this->expandCriteriaParameters($extraConditions);
  2054. $params = array_merge($params, $criteriaParams);
  2055. $types = array_merge($types, $criteriaTypes);
  2056. }
  2058. $filterSql = $this->generateFilterConditionSQL($this->class, $alias);
  2059. if ($filterSql) {
  2060. $sql .= ' AND ' . $filterSql;
  2061. }
  2063. return (bool) $this->conn->fetchOne($sql, $params, $types);
  2064. }
  2066. /**
  2067. * Generates the appropriate join SQL for the given join column.
  2068. *
  2069. * @param array[] $joinColumns The join columns definition of an association.
  2070. * @psalm-param array<array<string, mixed>> $joinColumns
  2071. *
  2072. * @return string LEFT JOIN if one of the columns is nullable, INNER JOIN otherwise.
  2073. */
  2074. protected function getJoinSQLForJoinColumns($joinColumns)
  2075. {
  2076. // if one of the join columns is nullable, return left join
  2077. foreach ($joinColumns as $joinColumn) {
  2078. if (! isset($joinColumn['nullable']) || $joinColumn['nullable']) {
  2079. return 'LEFT JOIN';
  2080. }
  2081. }
  2083. return 'INNER JOIN';
  2084. }
  2086. /**
  2087. * @param string $columnName
  2088. *
  2089. * @return string
  2090. */
  2091. public function getSQLColumnAlias($columnName)
  2092. {
  2093. return $this->quoteStrategy->getColumnAlias($columnName, $this->currentPersisterContext->sqlAliasCounter++, $this->platform);
  2094. }
  2096. /**
  2097. * Generates the filter SQL for a given entity and table alias.
  2098. *
  2099. * @param ClassMetadata $targetEntity Metadata of the target entity.
  2100. * @param string $targetTableAlias The table alias of the joined/selected table.
  2101. *
  2102. * @return string The SQL query part to add to a query.
  2103. */
  2104. protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
  2105. {
  2106. $filterClauses = [];
  2108. foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  2109. $filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
  2110. if ($filterExpr !== '') {
  2111. $filterClauses[] = '(' . $filterExpr . ')';
  2112. }
  2113. }
  2115. $sql = implode(' AND ', $filterClauses);
  2117. return $sql ? '(' . $sql . ')' : ''; // Wrap again to avoid "X or Y and FilterConditionSQL"
  2118. }
  2120. /**
  2121. * Switches persister context according to current query offset/limits
  2122. *
  2123. * This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved
  2124. *
  2125. * @param int|null $offset
  2126. * @param int|null $limit
  2127. *
  2128. * @return void
  2129. */
  2130. protected function switchPersisterContext($offset, $limit)
  2131. {
  2132. if ($offset === null && $limit === null) {
  2133. $this->currentPersisterContext = $this->noLimitsContext;
  2135. return;
  2136. }
  2138. $this->currentPersisterContext = $this->limitsHandlingContext;
  2139. }
  2141. /**
  2142. * @return string[]
  2143. * @psalm-return list<string>
  2144. */
  2145. protected function getClassIdentifiersTypes(ClassMetadata $class): array
  2146. {
  2147. $entityManager = $this->em;
  2149. return array_map(
  2150. static function ($fieldName) use ($class, $entityManager): string {
  2151. $types = PersisterHelper::getTypeOfField($fieldName, $class, $entityManager);
  2152. assert(isset($types[0]));
  2154. return $types[0];
  2155. },
  2156. $class->identifier
  2157. );
  2158. }
  2159. }