welcome back to dyb-tech
This commit is contained in:
Daniel Guzman
+68
@@ -0,0 +1,68 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Collection;
|
||||
|
||||
use Doctrine\DBAL\Connection;
|
||||
use Doctrine\DBAL\Platforms\AbstractPlatform;
|
||||
use Doctrine\ORM\EntityManagerInterface;
|
||||
use Doctrine\ORM\Mapping\QuoteStrategy;
|
||||
use Doctrine\ORM\UnitOfWork;
|
||||
|
||||
/**
|
||||
* Base class for all collection persisters.
|
||||
*/
|
||||
abstract class AbstractCollectionPersister implements CollectionPersister
|
||||
{
|
||||
/** @var EntityManagerInterface */
|
||||
protected $em;
|
||||
|
||||
/** @var Connection */
|
||||
protected $conn;
|
||||
|
||||
/** @var UnitOfWork */
|
||||
protected $uow;
|
||||
|
||||
/**
|
||||
* The database platform.
|
||||
*
|
||||
* @var AbstractPlatform
|
||||
*/
|
||||
protected $platform;
|
||||
|
||||
/** @var QuoteStrategy */
|
||||
protected $quoteStrategy;
|
||||
|
||||
/**
|
||||
* Initializes a new instance of a class derived from AbstractCollectionPersister.
|
||||
*/
|
||||
public function __construct(EntityManagerInterface $em)
|
||||
{
|
||||
$this->em = $em;
|
||||
$this->uow = $em->getUnitOfWork();
|
||||
$this->conn = $em->getConnection();
|
||||
$this->platform = $this->conn->getDatabasePlatform();
|
||||
$this->quoteStrategy = $em->getConfiguration()->getQuoteStrategy();
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if entity is in a valid state for operations.
|
||||
*
|
||||
* @param object $entity
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
protected function isValidEntityState($entity)
|
||||
{
|
||||
$entityState = $this->uow->getEntityState($entity, UnitOfWork::STATE_NEW);
|
||||
|
||||
if ($entityState === UnitOfWork::STATE_NEW) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// If Entity is scheduled for inclusion, it is not in this collection.
|
||||
// We can assure that because it would have return true before on array check
|
||||
return ! ($entityState === UnitOfWork::STATE_MANAGED && $this->uow->isScheduledForInsert($entity));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Collection;
|
||||
|
||||
use Doctrine\Common\Collections\Criteria;
|
||||
use Doctrine\ORM\PersistentCollection;
|
||||
|
||||
/**
|
||||
* Define the behavior that should be implemented by all collection persisters.
|
||||
*/
|
||||
interface CollectionPersister
|
||||
{
|
||||
/**
|
||||
* Deletes the persistent state represented by the given collection.
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function delete(PersistentCollection $collection);
|
||||
|
||||
/**
|
||||
* Updates the given collection, synchronizing its state with the database
|
||||
* by inserting, updating and deleting individual elements.
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function update(PersistentCollection $collection);
|
||||
|
||||
/**
|
||||
* Counts the size of this persistent collection.
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function count(PersistentCollection $collection);
|
||||
|
||||
/**
|
||||
* Slices elements.
|
||||
*
|
||||
* @param int $offset
|
||||
* @param int|null $length
|
||||
*
|
||||
* @return mixed[]
|
||||
*/
|
||||
public function slice(PersistentCollection $collection, $offset, $length = null);
|
||||
|
||||
/**
|
||||
* Checks for existence of an element.
|
||||
*
|
||||
* @param object $element
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function contains(PersistentCollection $collection, $element);
|
||||
|
||||
/**
|
||||
* Checks for existence of a key.
|
||||
*
|
||||
* @param mixed $key
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function containsKey(PersistentCollection $collection, $key);
|
||||
|
||||
/**
|
||||
* Gets an element by key.
|
||||
*
|
||||
* @param mixed $index
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
public function get(PersistentCollection $collection, $index);
|
||||
|
||||
/**
|
||||
* Loads association entities matching the given Criteria object.
|
||||
*
|
||||
* @return mixed[]
|
||||
*/
|
||||
public function loadCriteria(PersistentCollection $collection, Criteria $criteria);
|
||||
}
|
||||
@@ -0,0 +1,774 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Collection;
|
||||
|
||||
use BadMethodCallException;
|
||||
use Doctrine\Common\Collections\Criteria;
|
||||
use Doctrine\Common\Collections\Expr\Comparison;
|
||||
use Doctrine\DBAL\Exception as DBALException;
|
||||
use Doctrine\ORM\Mapping\ClassMetadata;
|
||||
use Doctrine\ORM\PersistentCollection;
|
||||
use Doctrine\ORM\Persisters\SqlValueVisitor;
|
||||
use Doctrine\ORM\Query;
|
||||
use Doctrine\ORM\Utility\PersisterHelper;
|
||||
|
||||
use function array_fill;
|
||||
use function array_pop;
|
||||
use function count;
|
||||
use function get_class;
|
||||
use function implode;
|
||||
use function in_array;
|
||||
use function reset;
|
||||
use function sprintf;
|
||||
|
||||
/**
|
||||
* Persister for many-to-many collections.
|
||||
*
|
||||
* @psalm-import-type AssociationMapping from ClassMetadata
|
||||
*/
|
||||
class ManyToManyPersister extends AbstractCollectionPersister
|
||||
{
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function delete(PersistentCollection $collection)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
|
||||
if (! $mapping['isOwningSide']) {
|
||||
return; // ignore inverse side
|
||||
}
|
||||
|
||||
$types = [];
|
||||
$class = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
|
||||
foreach ($mapping['joinTable']['joinColumns'] as $joinColumn) {
|
||||
$types[] = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $class, $this->em);
|
||||
}
|
||||
|
||||
$this->conn->executeStatement($this->getDeleteSQL($collection), $this->getDeleteSQLParameters($collection), $types);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function update(PersistentCollection $collection)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
|
||||
if (! $mapping['isOwningSide']) {
|
||||
return; // ignore inverse side
|
||||
}
|
||||
|
||||
[$deleteSql, $deleteTypes] = $this->getDeleteRowSQL($collection);
|
||||
[$insertSql, $insertTypes] = $this->getInsertRowSQL($collection);
|
||||
|
||||
foreach ($collection->getDeleteDiff() as $element) {
|
||||
$this->conn->executeStatement(
|
||||
$deleteSql,
|
||||
$this->getDeleteRowSQLParameters($collection, $element),
|
||||
$deleteTypes
|
||||
);
|
||||
}
|
||||
|
||||
foreach ($collection->getInsertDiff() as $element) {
|
||||
$this->conn->executeStatement(
|
||||
$insertSql,
|
||||
$this->getInsertRowSQLParameters($collection, $element),
|
||||
$insertTypes
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function get(PersistentCollection $collection, $index)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
|
||||
if (! isset($mapping['indexBy'])) {
|
||||
throw new BadMethodCallException('Selecting a collection by index is only supported on indexed collections.');
|
||||
}
|
||||
|
||||
$persister = $this->uow->getEntityPersister($mapping['targetEntity']);
|
||||
$mappedKey = $mapping['isOwningSide']
|
||||
? $mapping['inversedBy']
|
||||
: $mapping['mappedBy'];
|
||||
|
||||
return $persister->load([$mappedKey => $collection->getOwner(), $mapping['indexBy'] => $index], null, $mapping, [], 0, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function count(PersistentCollection $collection)
|
||||
{
|
||||
$conditions = [];
|
||||
$params = [];
|
||||
$types = [];
|
||||
$mapping = $collection->getMapping();
|
||||
$id = $this->uow->getEntityIdentifier($collection->getOwner());
|
||||
$sourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
$association = ! $mapping['isOwningSide']
|
||||
? $targetClass->associationMappings[$mapping['mappedBy']]
|
||||
: $mapping;
|
||||
|
||||
$joinTableName = $this->quoteStrategy->getJoinTableName($association, $sourceClass, $this->platform);
|
||||
$joinColumns = ! $mapping['isOwningSide']
|
||||
? $association['joinTable']['inverseJoinColumns']
|
||||
: $association['joinTable']['joinColumns'];
|
||||
|
||||
foreach ($joinColumns as $joinColumn) {
|
||||
$columnName = $this->quoteStrategy->getJoinColumnName($joinColumn, $sourceClass, $this->platform);
|
||||
$referencedName = $joinColumn['referencedColumnName'];
|
||||
$conditions[] = 't.' . $columnName . ' = ?';
|
||||
$params[] = $id[$sourceClass->getFieldForColumn($referencedName)];
|
||||
$types[] = PersisterHelper::getTypeOfColumn($referencedName, $sourceClass, $this->em);
|
||||
}
|
||||
|
||||
[$joinTargetEntitySQL, $filterSql] = $this->getFilterSql($mapping);
|
||||
|
||||
if ($filterSql) {
|
||||
$conditions[] = $filterSql;
|
||||
}
|
||||
|
||||
// If there is a provided criteria, make part of conditions
|
||||
// @todo Fix this. Current SQL returns something like:
|
||||
/*if ($criteria && ($expression = $criteria->getWhereExpression()) !== null) {
|
||||
// A join is needed on the target entity
|
||||
$targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
|
||||
$targetJoinSql = ' JOIN ' . $targetTableName . ' te'
|
||||
. ' ON' . implode(' AND ', $this->getOnConditionSQL($association));
|
||||
|
||||
// And criteria conditions needs to be added
|
||||
$persister = $this->uow->getEntityPersister($targetClass->name);
|
||||
$visitor = new SqlExpressionVisitor($persister, $targetClass);
|
||||
$conditions[] = $visitor->dispatch($expression);
|
||||
|
||||
$joinTargetEntitySQL = $targetJoinSql . $joinTargetEntitySQL;
|
||||
}*/
|
||||
|
||||
$sql = 'SELECT COUNT(*)'
|
||||
. ' FROM ' . $joinTableName . ' t'
|
||||
. $joinTargetEntitySQL
|
||||
. ' WHERE ' . implode(' AND ', $conditions);
|
||||
|
||||
return (int) $this->conn->fetchOne($sql, $params, $types);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function slice(PersistentCollection $collection, $offset, $length = null)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
$persister = $this->uow->getEntityPersister($mapping['targetEntity']);
|
||||
|
||||
return $persister->getManyToManyCollection($mapping, $collection->getOwner(), $offset, $length);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function containsKey(PersistentCollection $collection, $key)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
|
||||
if (! isset($mapping['indexBy'])) {
|
||||
throw new BadMethodCallException('Selecting a collection by index is only supported on indexed collections.');
|
||||
}
|
||||
|
||||
[$quotedJoinTable, $whereClauses, $params, $types] = $this->getJoinTableRestrictionsWithKey(
|
||||
$collection,
|
||||
(string) $key,
|
||||
true
|
||||
);
|
||||
|
||||
$sql = 'SELECT 1 FROM ' . $quotedJoinTable . ' WHERE ' . implode(' AND ', $whereClauses);
|
||||
|
||||
return (bool) $this->conn->fetchOne($sql, $params, $types);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function contains(PersistentCollection $collection, $element)
|
||||
{
|
||||
if (! $this->isValidEntityState($element)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
[$quotedJoinTable, $whereClauses, $params, $types] = $this->getJoinTableRestrictions(
|
||||
$collection,
|
||||
$element,
|
||||
true
|
||||
);
|
||||
|
||||
$sql = 'SELECT 1 FROM ' . $quotedJoinTable . ' WHERE ' . implode(' AND ', $whereClauses);
|
||||
|
||||
return (bool) $this->conn->fetchOne($sql, $params, $types);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function loadCriteria(PersistentCollection $collection, Criteria $criteria)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
$owner = $collection->getOwner();
|
||||
$ownerMetadata = $this->em->getClassMetadata(get_class($owner));
|
||||
$id = $this->uow->getEntityIdentifier($owner);
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
$onConditions = $this->getOnConditionSQL($mapping);
|
||||
$whereClauses = $params = [];
|
||||
$paramTypes = [];
|
||||
|
||||
if (! $mapping['isOwningSide']) {
|
||||
$associationSourceClass = $targetClass;
|
||||
$mapping = $targetClass->associationMappings[$mapping['mappedBy']];
|
||||
$sourceRelationMode = 'relationToTargetKeyColumns';
|
||||
} else {
|
||||
$associationSourceClass = $ownerMetadata;
|
||||
$sourceRelationMode = 'relationToSourceKeyColumns';
|
||||
}
|
||||
|
||||
foreach ($mapping[$sourceRelationMode] as $key => $value) {
|
||||
$whereClauses[] = sprintf('t.%s = ?', $key);
|
||||
$params[] = $ownerMetadata->containsForeignIdentifier
|
||||
? $id[$ownerMetadata->getFieldForColumn($value)]
|
||||
: $id[$ownerMetadata->fieldNames[$value]];
|
||||
$paramTypes[] = PersisterHelper::getTypeOfColumn($value, $ownerMetadata, $this->em);
|
||||
}
|
||||
|
||||
$parameters = $this->expandCriteriaParameters($criteria);
|
||||
|
||||
foreach ($parameters as $parameter) {
|
||||
[$name, $value, $operator] = $parameter;
|
||||
|
||||
$field = $this->quoteStrategy->getColumnName($name, $targetClass, $this->platform);
|
||||
|
||||
if ($value === null && ($operator === Comparison::EQ || $operator === Comparison::NEQ)) {
|
||||
$whereClauses[] = sprintf('te.%s %s NULL', $field, $operator === Comparison::EQ ? 'IS' : 'IS NOT');
|
||||
} else {
|
||||
$whereClauses[] = sprintf('te.%s %s ?', $field, $operator);
|
||||
$params[] = $value;
|
||||
$paramTypes[] = PersisterHelper::getTypeOfField($name, $targetClass, $this->em)[0];
|
||||
}
|
||||
}
|
||||
|
||||
$tableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
|
||||
$joinTable = $this->quoteStrategy->getJoinTableName($mapping, $associationSourceClass, $this->platform);
|
||||
|
||||
$rsm = new Query\ResultSetMappingBuilder($this->em);
|
||||
$rsm->addRootEntityFromClassMetadata($targetClass->name, 'te');
|
||||
|
||||
$sql = 'SELECT ' . $rsm->generateSelectClause()
|
||||
. ' FROM ' . $tableName . ' te'
|
||||
. ' JOIN ' . $joinTable . ' t ON'
|
||||
. implode(' AND ', $onConditions)
|
||||
. ' WHERE ' . implode(' AND ', $whereClauses);
|
||||
|
||||
$sql .= $this->getOrderingSql($criteria, $targetClass);
|
||||
|
||||
$sql .= $this->getLimitSql($criteria);
|
||||
|
||||
$stmt = $this->conn->executeQuery($sql, $params, $paramTypes);
|
||||
|
||||
return $this
|
||||
->em
|
||||
->newHydrator(Query::HYDRATE_OBJECT)
|
||||
->hydrateAll($stmt, $rsm);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates the filter SQL for a given mapping.
|
||||
*
|
||||
* This method is not used for actually grabbing the related entities
|
||||
* but when the extra-lazy collection methods are called on a filtered
|
||||
* association. This is why besides the many to many table we also
|
||||
* have to join in the actual entities table leading to additional
|
||||
* JOIN.
|
||||
*
|
||||
* @param mixed[] $mapping Array containing mapping information.
|
||||
* @psalm-param AssociationMapping $mapping
|
||||
*
|
||||
* @return string[] ordered tuple:
|
||||
* - JOIN condition to add to the SQL
|
||||
* - WHERE condition to add to the SQL
|
||||
* @psalm-return array{0: string, 1: string}
|
||||
*/
|
||||
public function getFilterSql($mapping)
|
||||
{
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
$rootClass = $this->em->getClassMetadata($targetClass->rootEntityName);
|
||||
$filterSql = $this->generateFilterConditionSQL($rootClass, 'te');
|
||||
|
||||
if ($filterSql === '') {
|
||||
return ['', ''];
|
||||
}
|
||||
|
||||
// A join is needed if there is filtering on the target entity
|
||||
$tableName = $this->quoteStrategy->getTableName($rootClass, $this->platform);
|
||||
$joinSql = ' JOIN ' . $tableName . ' te'
|
||||
. ' ON' . implode(' AND ', $this->getOnConditionSQL($mapping));
|
||||
|
||||
return [$joinSql, $filterSql];
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates the filter SQL for a given entity and table alias.
|
||||
*
|
||||
* @param ClassMetadata $targetEntity Metadata of the target entity.
|
||||
* @param string $targetTableAlias The table alias of the joined/selected table.
|
||||
*
|
||||
* @return string The SQL query part to add to a query.
|
||||
*/
|
||||
protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
|
||||
{
|
||||
$filterClauses = [];
|
||||
|
||||
foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
|
||||
$filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias);
|
||||
if ($filterExpr) {
|
||||
$filterClauses[] = '(' . $filterExpr . ')';
|
||||
}
|
||||
}
|
||||
|
||||
return $filterClauses
|
||||
? '(' . implode(' AND ', $filterClauses) . ')'
|
||||
: '';
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate ON condition
|
||||
*
|
||||
* @param mixed[] $mapping
|
||||
* @psalm-param AssociationMapping $mapping
|
||||
*
|
||||
* @return string[]
|
||||
* @psalm-return list<string>
|
||||
*/
|
||||
protected function getOnConditionSQL($mapping)
|
||||
{
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
$association = ! $mapping['isOwningSide']
|
||||
? $targetClass->associationMappings[$mapping['mappedBy']]
|
||||
: $mapping;
|
||||
|
||||
$joinColumns = $mapping['isOwningSide']
|
||||
? $association['joinTable']['inverseJoinColumns']
|
||||
: $association['joinTable']['joinColumns'];
|
||||
|
||||
$conditions = [];
|
||||
|
||||
foreach ($joinColumns as $joinColumn) {
|
||||
$joinColumnName = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
|
||||
$refColumnName = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
|
||||
|
||||
$conditions[] = ' t.' . $joinColumnName . ' = te.' . $refColumnName;
|
||||
}
|
||||
|
||||
return $conditions;
|
||||
}
|
||||
|
||||
/** @return string */
|
||||
protected function getDeleteSQL(PersistentCollection $collection)
|
||||
{
|
||||
$columns = [];
|
||||
$mapping = $collection->getMapping();
|
||||
$class = $this->em->getClassMetadata(get_class($collection->getOwner()));
|
||||
$joinTable = $this->quoteStrategy->getJoinTableName($mapping, $class, $this->platform);
|
||||
|
||||
foreach ($mapping['joinTable']['joinColumns'] as $joinColumn) {
|
||||
$columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
|
||||
}
|
||||
|
||||
return 'DELETE FROM ' . $joinTable
|
||||
. ' WHERE ' . implode(' = ? AND ', $columns) . ' = ?';
|
||||
}
|
||||
|
||||
/**
|
||||
* Internal note: Order of the parameters must be the same as the order of the columns in getDeleteSql.
|
||||
*
|
||||
* @return list<mixed>
|
||||
*/
|
||||
protected function getDeleteSQLParameters(PersistentCollection $collection)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
$identifier = $this->uow->getEntityIdentifier($collection->getOwner());
|
||||
|
||||
// Optimization for single column identifier
|
||||
if (count($mapping['relationToSourceKeyColumns']) === 1) {
|
||||
return [reset($identifier)];
|
||||
}
|
||||
|
||||
// Composite identifier
|
||||
$sourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
$params = [];
|
||||
|
||||
foreach ($mapping['relationToSourceKeyColumns'] as $columnName => $refColumnName) {
|
||||
$params[] = isset($sourceClass->fieldNames[$refColumnName])
|
||||
? $identifier[$sourceClass->fieldNames[$refColumnName]]
|
||||
: $identifier[$sourceClass->getFieldForColumn($refColumnName)];
|
||||
}
|
||||
|
||||
return $params;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the SQL statement used for deleting a row from the collection.
|
||||
*
|
||||
* @return string[]|string[][] ordered tuple containing the SQL to be executed and an array
|
||||
* of types for bound parameters
|
||||
* @psalm-return array{0: string, 1: list<string>}
|
||||
*/
|
||||
protected function getDeleteRowSQL(PersistentCollection $collection)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
$class = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
$columns = [];
|
||||
$types = [];
|
||||
|
||||
foreach ($mapping['joinTable']['joinColumns'] as $joinColumn) {
|
||||
$columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
|
||||
$types[] = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $class, $this->em);
|
||||
}
|
||||
|
||||
foreach ($mapping['joinTable']['inverseJoinColumns'] as $joinColumn) {
|
||||
$columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
|
||||
$types[] = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
|
||||
}
|
||||
|
||||
return [
|
||||
'DELETE FROM ' . $this->quoteStrategy->getJoinTableName($mapping, $class, $this->platform)
|
||||
. ' WHERE ' . implode(' = ? AND ', $columns) . ' = ?',
|
||||
$types,
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the SQL parameters for the corresponding SQL statement to delete the given
|
||||
* element from the given collection.
|
||||
*
|
||||
* Internal note: Order of the parameters must be the same as the order of the columns in getDeleteRowSql.
|
||||
*
|
||||
* @param mixed $element
|
||||
*
|
||||
* @return mixed[]
|
||||
* @psalm-return list<mixed>
|
||||
*/
|
||||
protected function getDeleteRowSQLParameters(PersistentCollection $collection, $element)
|
||||
{
|
||||
return $this->collectJoinTableColumnParameters($collection, $element);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the SQL statement used for inserting a row in the collection.
|
||||
*
|
||||
* @return string[]|string[][] ordered tuple containing the SQL to be executed and an array
|
||||
* of types for bound parameters
|
||||
* @psalm-return array{0: string, 1: list<string>}
|
||||
*/
|
||||
protected function getInsertRowSQL(PersistentCollection $collection)
|
||||
{
|
||||
$columns = [];
|
||||
$types = [];
|
||||
$mapping = $collection->getMapping();
|
||||
$class = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
|
||||
foreach ($mapping['joinTable']['joinColumns'] as $joinColumn) {
|
||||
$columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
|
||||
$types[] = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $class, $this->em);
|
||||
}
|
||||
|
||||
foreach ($mapping['joinTable']['inverseJoinColumns'] as $joinColumn) {
|
||||
$columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
|
||||
$types[] = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
|
||||
}
|
||||
|
||||
return [
|
||||
'INSERT INTO ' . $this->quoteStrategy->getJoinTableName($mapping, $class, $this->platform)
|
||||
. ' (' . implode(', ', $columns) . ')'
|
||||
. ' VALUES'
|
||||
. ' (' . implode(', ', array_fill(0, count($columns), '?')) . ')',
|
||||
$types,
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the SQL parameters for the corresponding SQL statement to insert the given
|
||||
* element of the given collection into the database.
|
||||
*
|
||||
* Internal note: Order of the parameters must be the same as the order of the columns in getInsertRowSql.
|
||||
*
|
||||
* @param object $element
|
||||
*
|
||||
* @return mixed[]
|
||||
* @psalm-return list<mixed>
|
||||
*/
|
||||
protected function getInsertRowSQLParameters(PersistentCollection $collection, $element)
|
||||
{
|
||||
return $this->collectJoinTableColumnParameters($collection, $element);
|
||||
}
|
||||
|
||||
/**
|
||||
* Collects the parameters for inserting/deleting on the join table in the order
|
||||
* of the join table columns as specified in ManyToManyMapping#joinTableColumns.
|
||||
*
|
||||
* @param object $element
|
||||
*
|
||||
* @return mixed[]
|
||||
* @psalm-return list<mixed>
|
||||
*/
|
||||
private function collectJoinTableColumnParameters(
|
||||
PersistentCollection $collection,
|
||||
$element
|
||||
): array {
|
||||
$params = [];
|
||||
$mapping = $collection->getMapping();
|
||||
$isComposite = count($mapping['joinTableColumns']) > 2;
|
||||
|
||||
$identifier1 = $this->uow->getEntityIdentifier($collection->getOwner());
|
||||
$identifier2 = $this->uow->getEntityIdentifier($element);
|
||||
|
||||
$class1 = $class2 = null;
|
||||
if ($isComposite) {
|
||||
$class1 = $this->em->getClassMetadata(get_class($collection->getOwner()));
|
||||
$class2 = $collection->getTypeClass();
|
||||
}
|
||||
|
||||
foreach ($mapping['joinTableColumns'] as $joinTableColumn) {
|
||||
$isRelationToSource = isset($mapping['relationToSourceKeyColumns'][$joinTableColumn]);
|
||||
|
||||
if (! $isComposite) {
|
||||
$params[] = $isRelationToSource ? array_pop($identifier1) : array_pop($identifier2);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($isRelationToSource) {
|
||||
$params[] = $identifier1[$class1->getFieldForColumn($mapping['relationToSourceKeyColumns'][$joinTableColumn])];
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
$params[] = $identifier2[$class2->getFieldForColumn($mapping['relationToTargetKeyColumns'][$joinTableColumn])];
|
||||
}
|
||||
|
||||
return $params;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param bool $addFilters Whether the filter SQL should be included or not.
|
||||
*
|
||||
* @return mixed[] ordered vector:
|
||||
* - quoted join table name
|
||||
* - where clauses to be added for filtering
|
||||
* - parameters to be bound for filtering
|
||||
* - types of the parameters to be bound for filtering
|
||||
* @psalm-return array{0: string, 1: list<string>, 2: list<mixed>, 3: list<string>}
|
||||
*/
|
||||
private function getJoinTableRestrictionsWithKey(
|
||||
PersistentCollection $collection,
|
||||
string $key,
|
||||
bool $addFilters
|
||||
): array {
|
||||
$filterMapping = $collection->getMapping();
|
||||
$mapping = $filterMapping;
|
||||
$indexBy = $mapping['indexBy'];
|
||||
$id = $this->uow->getEntityIdentifier($collection->getOwner());
|
||||
$sourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
|
||||
if (! $mapping['isOwningSide']) {
|
||||
$associationSourceClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
$mapping = $associationSourceClass->associationMappings[$mapping['mappedBy']];
|
||||
$joinColumns = $mapping['joinTable']['joinColumns'];
|
||||
$sourceRelationMode = 'relationToTargetKeyColumns';
|
||||
$targetRelationMode = 'relationToSourceKeyColumns';
|
||||
} else {
|
||||
$associationSourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
$joinColumns = $mapping['joinTable']['inverseJoinColumns'];
|
||||
$sourceRelationMode = 'relationToSourceKeyColumns';
|
||||
$targetRelationMode = 'relationToTargetKeyColumns';
|
||||
}
|
||||
|
||||
$quotedJoinTable = $this->quoteStrategy->getJoinTableName($mapping, $associationSourceClass, $this->platform) . ' t';
|
||||
$whereClauses = [];
|
||||
$params = [];
|
||||
$types = [];
|
||||
|
||||
$joinNeeded = ! in_array($indexBy, $targetClass->identifier, true);
|
||||
|
||||
if ($joinNeeded) { // extra join needed if indexBy is not a @id
|
||||
$joinConditions = [];
|
||||
|
||||
foreach ($joinColumns as $joinTableColumn) {
|
||||
$joinConditions[] = 't.' . $joinTableColumn['name'] . ' = tr.' . $joinTableColumn['referencedColumnName'];
|
||||
}
|
||||
|
||||
$tableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
|
||||
$quotedJoinTable .= ' JOIN ' . $tableName . ' tr ON ' . implode(' AND ', $joinConditions);
|
||||
$columnName = $targetClass->getColumnName($indexBy);
|
||||
|
||||
$whereClauses[] = 'tr.' . $columnName . ' = ?';
|
||||
$params[] = $key;
|
||||
$types[] = PersisterHelper::getTypeOfColumn($columnName, $targetClass, $this->em);
|
||||
}
|
||||
|
||||
foreach ($mapping['joinTableColumns'] as $joinTableColumn) {
|
||||
if (isset($mapping[$sourceRelationMode][$joinTableColumn])) {
|
||||
$column = $mapping[$sourceRelationMode][$joinTableColumn];
|
||||
$whereClauses[] = 't.' . $joinTableColumn . ' = ?';
|
||||
$params[] = $sourceClass->containsForeignIdentifier
|
||||
? $id[$sourceClass->getFieldForColumn($column)]
|
||||
: $id[$sourceClass->fieldNames[$column]];
|
||||
$types[] = PersisterHelper::getTypeOfColumn($column, $sourceClass, $this->em);
|
||||
} elseif (! $joinNeeded) {
|
||||
$column = $mapping[$targetRelationMode][$joinTableColumn];
|
||||
|
||||
$whereClauses[] = 't.' . $joinTableColumn . ' = ?';
|
||||
$params[] = $key;
|
||||
$types[] = PersisterHelper::getTypeOfColumn($column, $targetClass, $this->em);
|
||||
}
|
||||
}
|
||||
|
||||
if ($addFilters) {
|
||||
[$joinTargetEntitySQL, $filterSql] = $this->getFilterSql($filterMapping);
|
||||
|
||||
if ($filterSql) {
|
||||
$quotedJoinTable .= ' ' . $joinTargetEntitySQL;
|
||||
$whereClauses[] = $filterSql;
|
||||
}
|
||||
}
|
||||
|
||||
return [$quotedJoinTable, $whereClauses, $params, $types];
|
||||
}
|
||||
|
||||
/**
|
||||
* @param bool $addFilters Whether the filter SQL should be included or not.
|
||||
* @param object $element
|
||||
*
|
||||
* @return mixed[] ordered vector:
|
||||
* - quoted join table name
|
||||
* - where clauses to be added for filtering
|
||||
* - parameters to be bound for filtering
|
||||
* - types of the parameters to be bound for filtering
|
||||
* @psalm-return array{0: string, 1: list<string>, 2: list<mixed>, 3: list<string>}
|
||||
*/
|
||||
private function getJoinTableRestrictions(
|
||||
PersistentCollection $collection,
|
||||
$element,
|
||||
bool $addFilters
|
||||
): array {
|
||||
$filterMapping = $collection->getMapping();
|
||||
$mapping = $filterMapping;
|
||||
|
||||
if (! $mapping['isOwningSide']) {
|
||||
$sourceClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
$targetClass = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
$sourceId = $this->uow->getEntityIdentifier($element);
|
||||
$targetId = $this->uow->getEntityIdentifier($collection->getOwner());
|
||||
|
||||
$mapping = $sourceClass->associationMappings[$mapping['mappedBy']];
|
||||
} else {
|
||||
$sourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
$sourceId = $this->uow->getEntityIdentifier($collection->getOwner());
|
||||
$targetId = $this->uow->getEntityIdentifier($element);
|
||||
}
|
||||
|
||||
$quotedJoinTable = $this->quoteStrategy->getJoinTableName($mapping, $sourceClass, $this->platform);
|
||||
$whereClauses = [];
|
||||
$params = [];
|
||||
$types = [];
|
||||
|
||||
foreach ($mapping['joinTableColumns'] as $joinTableColumn) {
|
||||
$whereClauses[] = ($addFilters ? 't.' : '') . $joinTableColumn . ' = ?';
|
||||
|
||||
if (isset($mapping['relationToTargetKeyColumns'][$joinTableColumn])) {
|
||||
$targetColumn = $mapping['relationToTargetKeyColumns'][$joinTableColumn];
|
||||
$params[] = $targetId[$targetClass->getFieldForColumn($targetColumn)];
|
||||
$types[] = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// relationToSourceKeyColumns
|
||||
$targetColumn = $mapping['relationToSourceKeyColumns'][$joinTableColumn];
|
||||
$params[] = $sourceId[$sourceClass->getFieldForColumn($targetColumn)];
|
||||
$types[] = PersisterHelper::getTypeOfColumn($targetColumn, $sourceClass, $this->em);
|
||||
}
|
||||
|
||||
if ($addFilters) {
|
||||
$quotedJoinTable .= ' t';
|
||||
|
||||
[$joinTargetEntitySQL, $filterSql] = $this->getFilterSql($filterMapping);
|
||||
|
||||
if ($filterSql) {
|
||||
$quotedJoinTable .= ' ' . $joinTargetEntitySQL;
|
||||
$whereClauses[] = $filterSql;
|
||||
}
|
||||
}
|
||||
|
||||
return [$quotedJoinTable, $whereClauses, $params, $types];
|
||||
}
|
||||
|
||||
/**
|
||||
* Expands Criteria Parameters by walking the expressions and grabbing all
|
||||
* parameters and types from it.
|
||||
*
|
||||
* @return mixed[][]
|
||||
*/
|
||||
private function expandCriteriaParameters(Criteria $criteria): array
|
||||
{
|
||||
$expression = $criteria->getWhereExpression();
|
||||
|
||||
if ($expression === null) {
|
||||
return [];
|
||||
}
|
||||
|
||||
$valueVisitor = new SqlValueVisitor();
|
||||
|
||||
$valueVisitor->dispatch($expression);
|
||||
|
||||
[, $types] = $valueVisitor->getParamsAndTypes();
|
||||
|
||||
return $types;
|
||||
}
|
||||
|
||||
private function getOrderingSql(Criteria $criteria, ClassMetadata $targetClass): string
|
||||
{
|
||||
$orderings = $criteria->getOrderings();
|
||||
if ($orderings) {
|
||||
$orderBy = [];
|
||||
foreach ($orderings as $name => $direction) {
|
||||
$field = $this->quoteStrategy->getColumnName(
|
||||
$name,
|
||||
$targetClass,
|
||||
$this->platform
|
||||
);
|
||||
$orderBy[] = $field . ' ' . $direction;
|
||||
}
|
||||
|
||||
return ' ORDER BY ' . implode(', ', $orderBy);
|
||||
}
|
||||
|
||||
return '';
|
||||
}
|
||||
|
||||
/** @throws DBALException */
|
||||
private function getLimitSql(Criteria $criteria): string
|
||||
{
|
||||
$limit = $criteria->getMaxResults();
|
||||
$offset = $criteria->getFirstResult();
|
||||
|
||||
return $this->platform->modifyLimitQuery('', $limit, $offset ?? 0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,261 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Collection;
|
||||
|
||||
use BadMethodCallException;
|
||||
use Doctrine\Common\Collections\Criteria;
|
||||
use Doctrine\DBAL\Exception as DBALException;
|
||||
use Doctrine\DBAL\Types\Type;
|
||||
use Doctrine\ORM\PersistentCollection;
|
||||
use Doctrine\ORM\Utility\PersisterHelper;
|
||||
|
||||
use function array_merge;
|
||||
use function array_reverse;
|
||||
use function array_values;
|
||||
use function assert;
|
||||
use function implode;
|
||||
use function is_int;
|
||||
use function is_string;
|
||||
|
||||
/**
|
||||
* Persister for one-to-many collections.
|
||||
*/
|
||||
class OneToManyPersister extends AbstractCollectionPersister
|
||||
{
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* @return int|null
|
||||
*/
|
||||
public function delete(PersistentCollection $collection)
|
||||
{
|
||||
// The only valid case here is when you have weak entities. In this
|
||||
// scenario, you have @OneToMany with orphanRemoval=true, and replacing
|
||||
// the entire collection with a new would trigger this operation.
|
||||
$mapping = $collection->getMapping();
|
||||
|
||||
if (! $mapping['orphanRemoval']) {
|
||||
// Handling non-orphan removal should never happen, as @OneToMany
|
||||
// can only be inverse side. For owning side one to many, it is
|
||||
// required to have a join table, which would classify as a ManyToManyPersister.
|
||||
return;
|
||||
}
|
||||
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
|
||||
return $targetClass->isInheritanceTypeJoined()
|
||||
? $this->deleteJoinedEntityCollection($collection)
|
||||
: $this->deleteEntityCollection($collection);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function update(PersistentCollection $collection)
|
||||
{
|
||||
// This can never happen. One to many can only be inverse side.
|
||||
// For owning side one to many, it is required to have a join table,
|
||||
// then classifying it as a ManyToManyPersister.
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function get(PersistentCollection $collection, $index)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
|
||||
if (! isset($mapping['indexBy'])) {
|
||||
throw new BadMethodCallException('Selecting a collection by index is only supported on indexed collections.');
|
||||
}
|
||||
|
||||
$persister = $this->uow->getEntityPersister($mapping['targetEntity']);
|
||||
|
||||
return $persister->load(
|
||||
[
|
||||
$mapping['mappedBy'] => $collection->getOwner(),
|
||||
$mapping['indexBy'] => $index,
|
||||
],
|
||||
null,
|
||||
$mapping,
|
||||
[],
|
||||
null,
|
||||
1
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function count(PersistentCollection $collection)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
$persister = $this->uow->getEntityPersister($mapping['targetEntity']);
|
||||
|
||||
// only works with single id identifier entities. Will throw an
|
||||
// exception in Entity Persisters if that is not the case for the
|
||||
// 'mappedBy' field.
|
||||
$criteria = new Criteria(Criteria::expr()->eq($mapping['mappedBy'], $collection->getOwner()));
|
||||
|
||||
return $persister->count($criteria);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function slice(PersistentCollection $collection, $offset, $length = null)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
$persister = $this->uow->getEntityPersister($mapping['targetEntity']);
|
||||
|
||||
return $persister->getOneToManyCollection($mapping, $collection->getOwner(), $offset, $length);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function containsKey(PersistentCollection $collection, $key)
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
|
||||
if (! isset($mapping['indexBy'])) {
|
||||
throw new BadMethodCallException('Selecting a collection by index is only supported on indexed collections.');
|
||||
}
|
||||
|
||||
$persister = $this->uow->getEntityPersister($mapping['targetEntity']);
|
||||
|
||||
// only works with single id identifier entities. Will throw an
|
||||
// exception in Entity Persisters if that is not the case for the
|
||||
// 'mappedBy' field.
|
||||
$criteria = new Criteria();
|
||||
|
||||
$criteria->andWhere(Criteria::expr()->eq($mapping['mappedBy'], $collection->getOwner()));
|
||||
$criteria->andWhere(Criteria::expr()->eq($mapping['indexBy'], $key));
|
||||
|
||||
return (bool) $persister->count($criteria);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function contains(PersistentCollection $collection, $element)
|
||||
{
|
||||
if (! $this->isValidEntityState($element)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$mapping = $collection->getMapping();
|
||||
$persister = $this->uow->getEntityPersister($mapping['targetEntity']);
|
||||
|
||||
// only works with single id identifier entities. Will throw an
|
||||
// exception in Entity Persisters if that is not the case for the
|
||||
// 'mappedBy' field.
|
||||
$criteria = new Criteria(Criteria::expr()->eq($mapping['mappedBy'], $collection->getOwner()));
|
||||
|
||||
return $persister->exists($element, $criteria);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function loadCriteria(PersistentCollection $collection, Criteria $criteria)
|
||||
{
|
||||
throw new BadMethodCallException('Filtering a collection by Criteria is not supported by this CollectionPersister.');
|
||||
}
|
||||
|
||||
/** @throws DBALException */
|
||||
private function deleteEntityCollection(PersistentCollection $collection): int
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
$identifier = $this->uow->getEntityIdentifier($collection->getOwner());
|
||||
$sourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
$columns = [];
|
||||
$parameters = [];
|
||||
$types = [];
|
||||
|
||||
foreach ($targetClass->associationMappings[$mapping['mappedBy']]['joinColumns'] as $joinColumn) {
|
||||
$columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
|
||||
$parameters[] = $identifier[$sourceClass->getFieldForColumn($joinColumn['referencedColumnName'])];
|
||||
$types[] = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $sourceClass, $this->em);
|
||||
}
|
||||
|
||||
$statement = 'DELETE FROM ' . $this->quoteStrategy->getTableName($targetClass, $this->platform)
|
||||
. ' WHERE ' . implode(' = ? AND ', $columns) . ' = ?';
|
||||
|
||||
$numAffected = $this->conn->executeStatement($statement, $parameters, $types);
|
||||
|
||||
assert(is_int($numAffected));
|
||||
|
||||
return $numAffected;
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete Class Table Inheritance entities.
|
||||
* A temporary table is needed to keep IDs to be deleted in both parent and child class' tables.
|
||||
*
|
||||
* Thanks Steve Ebersole (Hibernate) for idea on how to tackle reliably this scenario, we owe him a beer! =)
|
||||
*
|
||||
* @throws DBALException
|
||||
*/
|
||||
private function deleteJoinedEntityCollection(PersistentCollection $collection): int
|
||||
{
|
||||
$mapping = $collection->getMapping();
|
||||
$sourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
$rootClass = $this->em->getClassMetadata($targetClass->rootEntityName);
|
||||
|
||||
// 1) Build temporary table DDL
|
||||
$tempTable = $this->platform->getTemporaryTableName($rootClass->getTemporaryIdTableName());
|
||||
$idColumnNames = $rootClass->getIdentifierColumnNames();
|
||||
$idColumnList = implode(', ', $idColumnNames);
|
||||
$columnDefinitions = [];
|
||||
|
||||
foreach ($idColumnNames as $idColumnName) {
|
||||
$columnDefinitions[$idColumnName] = [
|
||||
'notnull' => true,
|
||||
'type' => Type::getType(PersisterHelper::getTypeOfColumn($idColumnName, $rootClass, $this->em)),
|
||||
];
|
||||
}
|
||||
|
||||
$statement = $this->platform->getCreateTemporaryTableSnippetSQL() . ' ' . $tempTable
|
||||
. ' (' . $this->platform->getColumnDeclarationListSQL($columnDefinitions) . ')';
|
||||
|
||||
$this->conn->executeStatement($statement);
|
||||
|
||||
// 2) Build insert table records into temporary table
|
||||
$query = $this->em->createQuery(
|
||||
' SELECT t0.' . implode(', t0.', $rootClass->getIdentifierFieldNames())
|
||||
. ' FROM ' . $targetClass->name . ' t0 WHERE t0.' . $mapping['mappedBy'] . ' = :owner'
|
||||
)->setParameter('owner', $collection->getOwner());
|
||||
|
||||
$sql = $query->getSQL();
|
||||
assert(is_string($sql));
|
||||
$statement = 'INSERT INTO ' . $tempTable . ' (' . $idColumnList . ') ' . $sql;
|
||||
$parameters = array_values($sourceClass->getIdentifierValues($collection->getOwner()));
|
||||
$numDeleted = $this->conn->executeStatement($statement, $parameters);
|
||||
|
||||
// 3) Delete records on each table in the hierarchy
|
||||
$classNames = array_merge($targetClass->parentClasses, [$targetClass->name], $targetClass->subClasses);
|
||||
|
||||
foreach (array_reverse($classNames) as $className) {
|
||||
$tableName = $this->quoteStrategy->getTableName($this->em->getClassMetadata($className), $this->platform);
|
||||
$statement = 'DELETE FROM ' . $tableName . ' WHERE (' . $idColumnList . ')'
|
||||
. ' IN (SELECT ' . $idColumnList . ' FROM ' . $tempTable . ')';
|
||||
|
||||
$this->conn->executeStatement($statement);
|
||||
}
|
||||
|
||||
// 4) Drop temporary table
|
||||
$statement = $this->platform->getDropTemporaryTableSQL($tempTable);
|
||||
|
||||
$this->conn->executeStatement($statement);
|
||||
|
||||
assert(is_int($numDeleted));
|
||||
|
||||
return $numDeleted;
|
||||
}
|
||||
}
|
||||
+81
@@ -0,0 +1,81 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Entity;
|
||||
|
||||
use Doctrine\DBAL\Types\Type;
|
||||
use Doctrine\ORM\Mapping\ClassMetadata;
|
||||
|
||||
use function sprintf;
|
||||
|
||||
/**
|
||||
* Base class for entity persisters that implement a certain inheritance mapping strategy.
|
||||
* All these persisters are assumed to use a discriminator column to discriminate entity
|
||||
* types in the hierarchy.
|
||||
*/
|
||||
abstract class AbstractEntityInheritancePersister extends BasicEntityPersister
|
||||
{
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function prepareInsertData($entity)
|
||||
{
|
||||
$data = parent::prepareInsertData($entity);
|
||||
|
||||
// Populate the discriminator column
|
||||
$discColumn = $this->class->getDiscriminatorColumn();
|
||||
$this->columnTypes[$discColumn['name']] = $discColumn['type'];
|
||||
$data[$this->getDiscriminatorColumnTableName()][$discColumn['name']] = $this->class->discriminatorValue;
|
||||
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the name of the table that contains the discriminator column.
|
||||
*
|
||||
* @return string The table name.
|
||||
*/
|
||||
abstract protected function getDiscriminatorColumnTableName();
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r')
|
||||
{
|
||||
$tableAlias = $alias === 'r' ? '' : $alias;
|
||||
$fieldMapping = $class->fieldMappings[$field];
|
||||
$columnAlias = $this->getSQLColumnAlias($fieldMapping['columnName']);
|
||||
$sql = sprintf(
|
||||
'%s.%s',
|
||||
$this->getSQLTableAlias($class->name, $tableAlias),
|
||||
$this->quoteStrategy->getColumnName($field, $class, $this->platform)
|
||||
);
|
||||
|
||||
$this->currentPersisterContext->rsm->addFieldResult($alias, $columnAlias, $field, $class->name);
|
||||
|
||||
if (isset($fieldMapping['requireSQLConversion'])) {
|
||||
$type = Type::getType($fieldMapping['type']);
|
||||
$sql = $type->convertToPHPValueSQL($sql, $this->platform);
|
||||
}
|
||||
|
||||
return $sql . ' AS ' . $columnAlias;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $tableAlias
|
||||
* @param string $joinColumnName
|
||||
* @param string $quotedColumnName
|
||||
* @param string $type
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
protected function getSelectJoinColumnSQL($tableAlias, $joinColumnName, $quotedColumnName, $type)
|
||||
{
|
||||
$columnAlias = $this->getSQLColumnAlias($joinColumnName);
|
||||
|
||||
$this->currentPersisterContext->rsm->addMetaResult('r', $columnAlias, $joinColumnName, false, $type);
|
||||
|
||||
return $tableAlias . '.' . $quotedColumnName . ' AS ' . $columnAlias;
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,82 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Entity;
|
||||
|
||||
use Doctrine\ORM\Query\ResultSetMapping;
|
||||
use Doctrine\Persistence\Mapping\ClassMetadata;
|
||||
|
||||
/**
|
||||
* A swappable persister context to use as a container for the current
|
||||
* generated query/resultSetMapping/type binding information.
|
||||
*
|
||||
* This class is a utility class to be used only by the persister API
|
||||
*
|
||||
* This object is highly mutable due to performance reasons. Same reasoning
|
||||
* behind its properties being public.
|
||||
*/
|
||||
class CachedPersisterContext
|
||||
{
|
||||
/**
|
||||
* Metadata object that describes the mapping of the mapped entity class.
|
||||
*
|
||||
* @var \Doctrine\ORM\Mapping\ClassMetadata
|
||||
*/
|
||||
public $class;
|
||||
|
||||
/**
|
||||
* ResultSetMapping that is used for all queries. Is generated lazily once per request.
|
||||
*
|
||||
* @var ResultSetMapping
|
||||
*/
|
||||
public $rsm;
|
||||
|
||||
/**
|
||||
* The SELECT column list SQL fragment used for querying entities by this persister.
|
||||
* This SQL fragment is only generated once per request, if at all.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $selectColumnListSql;
|
||||
|
||||
/**
|
||||
* The JOIN SQL fragment used to eagerly load all many-to-one and one-to-one
|
||||
* associations configured as FETCH_EAGER, as well as all inverse one-to-one associations.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $selectJoinSql;
|
||||
|
||||
/**
|
||||
* Counter for creating unique SQL table and column aliases.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
public $sqlAliasCounter = 0;
|
||||
|
||||
/**
|
||||
* Map from class names (FQCN) to the corresponding generated SQL table aliases.
|
||||
*
|
||||
* @var array<class-string, string>
|
||||
*/
|
||||
public $sqlTableAliases = [];
|
||||
|
||||
/**
|
||||
* Whether this persistent context is considering limit operations applied to the selection queries
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
public $handlesLimits;
|
||||
|
||||
/** @param bool $handlesLimits */
|
||||
public function __construct(
|
||||
ClassMetadata $class,
|
||||
ResultSetMapping $rsm,
|
||||
$handlesLimits
|
||||
) {
|
||||
$this->class = $class;
|
||||
$this->rsm = $rsm;
|
||||
$this->handlesLimits = (bool) $handlesLimits;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,329 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Entity;
|
||||
|
||||
use Doctrine\Common\Collections\Criteria;
|
||||
use Doctrine\DBAL\LockMode;
|
||||
use Doctrine\ORM\Mapping\ClassMetadata;
|
||||
use Doctrine\ORM\Mapping\MappingException;
|
||||
use Doctrine\ORM\PersistentCollection;
|
||||
use Doctrine\ORM\Query\ResultSetMapping;
|
||||
|
||||
/**
|
||||
* Entity persister interface
|
||||
* Define the behavior that should be implemented by all entity persisters.
|
||||
*
|
||||
* @psalm-import-type AssociationMapping from ClassMetadata
|
||||
*/
|
||||
interface EntityPersister
|
||||
{
|
||||
/** @return ClassMetadata */
|
||||
public function getClassMetadata();
|
||||
|
||||
/**
|
||||
* Gets the ResultSetMapping used for hydration.
|
||||
*
|
||||
* @return ResultSetMapping
|
||||
*/
|
||||
public function getResultSetMapping();
|
||||
|
||||
/**
|
||||
* Get all queued inserts.
|
||||
*
|
||||
* @return object[]
|
||||
*/
|
||||
public function getInserts();
|
||||
|
||||
/**
|
||||
* Gets the INSERT SQL used by the persister to persist a new entity.
|
||||
*
|
||||
* @return string
|
||||
*
|
||||
* @TODO It should not be here.
|
||||
* But its necessary since JoinedSubclassPersister#executeInserts invoke the root persister.
|
||||
*/
|
||||
public function getInsertSQL();
|
||||
|
||||
/**
|
||||
* Gets the SELECT SQL to select one or more entities by a set of field criteria.
|
||||
*
|
||||
* @param mixed[]|Criteria $criteria
|
||||
* @param int|null $lockMode
|
||||
* @param int|null $limit
|
||||
* @param int|null $offset
|
||||
* @param mixed[]|null $orderBy
|
||||
* @psalm-param AssociationMapping|null $assoc
|
||||
* @psalm-param LockMode::*|null $lockMode
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, ?array $orderBy = null);
|
||||
|
||||
/**
|
||||
* Get the COUNT SQL to count entities (optionally based on a criteria)
|
||||
*
|
||||
* @param mixed[]|Criteria $criteria
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getCountSQL($criteria = []);
|
||||
|
||||
/**
|
||||
* Expands the parameters from the given criteria and use the correct binding types if found.
|
||||
*
|
||||
* @param string[] $criteria
|
||||
*
|
||||
* @psalm-return array{list<mixed>, list<int|string|null>}
|
||||
*/
|
||||
public function expandParameters($criteria);
|
||||
|
||||
/**
|
||||
* Expands Criteria Parameters by walking the expressions and grabbing all parameters and types from it.
|
||||
*
|
||||
* @psalm-return array{list<mixed>, list<int|string|null>}
|
||||
*/
|
||||
public function expandCriteriaParameters(Criteria $criteria);
|
||||
|
||||
/**
|
||||
* Gets the SQL WHERE condition for matching a field with a given value.
|
||||
*
|
||||
* @param string $field
|
||||
* @param mixed $value
|
||||
* @param AssociationMapping|null $assoc
|
||||
* @param string|null $comparison
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getSelectConditionStatementSQL($field, $value, $assoc = null, $comparison = null);
|
||||
|
||||
/**
|
||||
* Adds an entity to the queued insertions.
|
||||
* The entity remains queued until {@link executeInserts} is invoked.
|
||||
*
|
||||
* @param object $entity The entity to queue for insertion.
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function addInsert($entity);
|
||||
|
||||
/**
|
||||
* Executes all queued entity insertions.
|
||||
*
|
||||
* If no inserts are queued, invoking this method is a NOOP.
|
||||
*
|
||||
* @psalm-return void|list<array{
|
||||
* generatedId: int,
|
||||
* entity: object
|
||||
* }> Returning an array of generated post-insert IDs is deprecated, implementations
|
||||
* should call UnitOfWork::assignPostInsertId() and return void.
|
||||
*/
|
||||
public function executeInserts();
|
||||
|
||||
/**
|
||||
* Updates a managed entity. The entity is updated according to its current changeset
|
||||
* in the running UnitOfWork. If there is no changeset, nothing is updated.
|
||||
*
|
||||
* @param object $entity The entity to update.
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function update($entity);
|
||||
|
||||
/**
|
||||
* Deletes a managed entity.
|
||||
*
|
||||
* The entity to delete must be managed and have a persistent identifier.
|
||||
* The deletion happens instantaneously.
|
||||
*
|
||||
* Subclasses may override this method to customize the semantics of entity deletion.
|
||||
*
|
||||
* @param object $entity The entity to delete.
|
||||
*
|
||||
* @return bool TRUE if the entity got deleted in the database, FALSE otherwise.
|
||||
*/
|
||||
public function delete($entity);
|
||||
|
||||
/**
|
||||
* Count entities (optionally filtered by a criteria)
|
||||
*
|
||||
* @param mixed[]|Criteria $criteria
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function count($criteria = []);
|
||||
|
||||
/**
|
||||
* Gets the name of the table that owns the column the given field is mapped to.
|
||||
*
|
||||
* The default implementation in BasicEntityPersister always returns the name
|
||||
* of the table the entity type of this persister is mapped to, since an entity
|
||||
* is always persisted to a single table with a BasicEntityPersister.
|
||||
*
|
||||
* @param string $fieldName The field name.
|
||||
*
|
||||
* @return string The table name.
|
||||
*/
|
||||
public function getOwningTable($fieldName);
|
||||
|
||||
/**
|
||||
* Loads an entity by a list of field criteria.
|
||||
*
|
||||
* @param mixed[] $criteria The criteria by which to load the entity.
|
||||
* @param object|null $entity The entity to load the data into. If not specified,
|
||||
* a new entity is created.
|
||||
* @param AssociationMapping|null $assoc The association that connects the entity
|
||||
* to load to another entity, if any.
|
||||
* @param mixed[] $hints Hints for entity creation.
|
||||
* @param int|null $lockMode One of the \Doctrine\DBAL\LockMode::* constants
|
||||
* or NULL if no specific lock mode should be used
|
||||
* for loading the entity.
|
||||
* @param int|null $limit Limit number of results.
|
||||
* @param string[]|null $orderBy Criteria to order by.
|
||||
* @psalm-param array<string, mixed> $criteria
|
||||
* @psalm-param array<string, mixed> $hints
|
||||
* @psalm-param LockMode::*|null $lockMode
|
||||
* @psalm-param array<string, string>|null $orderBy
|
||||
*
|
||||
* @return object|null The loaded and managed entity instance or NULL if the entity can not be found.
|
||||
*
|
||||
* @todo Check identity map? loadById method? Try to guess whether $criteria is the id?
|
||||
*/
|
||||
public function load(
|
||||
array $criteria,
|
||||
$entity = null,
|
||||
$assoc = null,
|
||||
array $hints = [],
|
||||
$lockMode = null,
|
||||
$limit = null,
|
||||
?array $orderBy = null
|
||||
);
|
||||
|
||||
/**
|
||||
* Loads an entity by identifier.
|
||||
*
|
||||
* @param object|null $entity The entity to load the data into. If not specified, a new entity is created.
|
||||
* @psalm-param array<string, mixed> $identifier The entity identifier.
|
||||
*
|
||||
* @return object|null The loaded and managed entity instance or NULL if the entity can not be found.
|
||||
*
|
||||
* @todo Check parameters
|
||||
*/
|
||||
public function loadById(array $identifier, $entity = null);
|
||||
|
||||
/**
|
||||
* Loads an entity of this persister's mapped class as part of a single-valued
|
||||
* association from another entity.
|
||||
*
|
||||
* @param object $sourceEntity The entity that owns the association (not necessarily the "owning side").
|
||||
* @psalm-param array<string, mixed> $identifier The identifier of the entity to load. Must be provided if
|
||||
* the association to load represents the owning side, otherwise
|
||||
* the identifier is derived from the $sourceEntity.
|
||||
* @psalm-param AssociationMapping $assoc The association to load.
|
||||
*
|
||||
* @return object The loaded and managed entity instance or NULL if the entity can not be found.
|
||||
*
|
||||
* @throws MappingException
|
||||
*/
|
||||
public function loadOneToOneEntity(array $assoc, $sourceEntity, array $identifier = []);
|
||||
|
||||
/**
|
||||
* Refreshes a managed entity.
|
||||
*
|
||||
* @param object $entity The entity to refresh.
|
||||
* @param int|null $lockMode One of the \Doctrine\DBAL\LockMode::* constants
|
||||
* or NULL if no specific lock mode should be used
|
||||
* for refreshing the managed entity.
|
||||
* @psalm-param array<string, mixed> $id The identifier of the entity as an
|
||||
* associative array from column or
|
||||
* field names to values.
|
||||
* @psalm-param LockMode::*|null $lockMode
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function refresh(array $id, $entity, $lockMode = null);
|
||||
|
||||
/**
|
||||
* Loads Entities matching the given Criteria object.
|
||||
*
|
||||
* @return mixed[]
|
||||
*/
|
||||
public function loadCriteria(Criteria $criteria);
|
||||
|
||||
/**
|
||||
* Loads a list of entities by a list of field criteria.
|
||||
*
|
||||
* @param int|null $limit
|
||||
* @param int|null $offset
|
||||
* @psalm-param array<string, string>|null $orderBy
|
||||
* @psalm-param array<string, mixed> $criteria
|
||||
*/
|
||||
public function loadAll(array $criteria = [], ?array $orderBy = null, $limit = null, $offset = null);
|
||||
|
||||
/**
|
||||
* Gets (sliced or full) elements of the given collection.
|
||||
*
|
||||
* @param object $sourceEntity
|
||||
* @param int|null $offset
|
||||
* @param int|null $limit
|
||||
* @psalm-param AssociationMapping $assoc
|
||||
*
|
||||
* @return mixed[]
|
||||
*/
|
||||
public function getManyToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null);
|
||||
|
||||
/**
|
||||
* Loads a collection of entities of a many-to-many association.
|
||||
*
|
||||
* @param object $sourceEntity The entity that owns the collection.
|
||||
* @param PersistentCollection $collection The collection to fill.
|
||||
* @psalm-param AssociationMapping $assoc The association mapping of the association being loaded.
|
||||
*
|
||||
* @return mixed[]
|
||||
*/
|
||||
public function loadManyToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection);
|
||||
|
||||
/**
|
||||
* Loads a collection of entities in a one-to-many association.
|
||||
*
|
||||
* @param object $sourceEntity
|
||||
* @param PersistentCollection $collection The collection to load/fill.
|
||||
* @psalm-param AssociationMapping $assoc
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
public function loadOneToManyCollection(array $assoc, $sourceEntity, PersistentCollection $collection);
|
||||
|
||||
/**
|
||||
* Locks all rows of this entity matching the given criteria with the specified pessimistic lock mode.
|
||||
*
|
||||
* @param int $lockMode One of the Doctrine\DBAL\LockMode::* constants.
|
||||
* @psalm-param array<string, mixed> $criteria
|
||||
* @psalm-param LockMode::* $lockMode
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function lock(array $criteria, $lockMode);
|
||||
|
||||
/**
|
||||
* Returns an array with (sliced or full list) of elements in the specified collection.
|
||||
*
|
||||
* @param object $sourceEntity
|
||||
* @param int|null $offset
|
||||
* @param int|null $limit
|
||||
* @psalm-param AssociationMapping $assoc
|
||||
*
|
||||
* @return mixed[]
|
||||
*/
|
||||
public function getOneToManyCollection(array $assoc, $sourceEntity, $offset = null, $limit = null);
|
||||
|
||||
/**
|
||||
* Checks whether the given managed entity exists in the database.
|
||||
*
|
||||
* @param object $entity
|
||||
*
|
||||
* @return bool TRUE if the entity exists in the database, FALSE otherwise.
|
||||
*/
|
||||
public function exists($entity, ?Criteria $extraConditions = null);
|
||||
}
|
||||
@@ -0,0 +1,650 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Entity;
|
||||
|
||||
use Doctrine\Common\Collections\Criteria;
|
||||
use Doctrine\DBAL\LockMode;
|
||||
use Doctrine\DBAL\Types\Type;
|
||||
use Doctrine\DBAL\Types\Types;
|
||||
use Doctrine\ORM\Internal\SQLResultCasing;
|
||||
use Doctrine\ORM\Mapping\ClassMetadata;
|
||||
use Doctrine\ORM\Utility\LockSqlHelper;
|
||||
use Doctrine\ORM\Utility\PersisterHelper;
|
||||
use LengthException;
|
||||
|
||||
use function array_combine;
|
||||
use function array_keys;
|
||||
use function array_values;
|
||||
use function implode;
|
||||
|
||||
/**
|
||||
* The joined subclass persister maps a single entity instance to several tables in the
|
||||
* database as it is defined by the <tt>Class Table Inheritance</tt> strategy.
|
||||
*
|
||||
* @see https://martinfowler.com/eaaCatalog/classTableInheritance.html
|
||||
*/
|
||||
class JoinedSubclassPersister extends AbstractEntityInheritancePersister
|
||||
{
|
||||
use LockSqlHelper;
|
||||
use SQLResultCasing;
|
||||
|
||||
/**
|
||||
* Map that maps column names to the table names that own them.
|
||||
* This is mainly a temporary cache, used during a single request.
|
||||
*
|
||||
* @psalm-var array<string, string>
|
||||
*/
|
||||
private $owningTableMap = [];
|
||||
|
||||
/**
|
||||
* Map of table to quoted table names.
|
||||
*
|
||||
* @psalm-var array<string, string>
|
||||
*/
|
||||
private $quotedTableMap = [];
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDiscriminatorColumnTableName()
|
||||
{
|
||||
$class = $this->class->name !== $this->class->rootEntityName
|
||||
? $this->em->getClassMetadata($this->class->rootEntityName)
|
||||
: $this->class;
|
||||
|
||||
return $class->getTableName();
|
||||
}
|
||||
|
||||
/**
|
||||
* This function finds the ClassMetadata instance in an inheritance hierarchy
|
||||
* that is responsible for enabling versioning.
|
||||
*/
|
||||
private function getVersionedClassMetadata(): ClassMetadata
|
||||
{
|
||||
if (isset($this->class->fieldMappings[$this->class->versionField]['inherited'])) {
|
||||
$definingClassName = $this->class->fieldMappings[$this->class->versionField]['inherited'];
|
||||
|
||||
return $this->em->getClassMetadata($definingClassName);
|
||||
}
|
||||
|
||||
return $this->class;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the name of the table that owns the column the given field is mapped to.
|
||||
*
|
||||
* @param string $fieldName
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getOwningTable($fieldName)
|
||||
{
|
||||
if (isset($this->owningTableMap[$fieldName])) {
|
||||
return $this->owningTableMap[$fieldName];
|
||||
}
|
||||
|
||||
switch (true) {
|
||||
case isset($this->class->associationMappings[$fieldName]['inherited']):
|
||||
$cm = $this->em->getClassMetadata($this->class->associationMappings[$fieldName]['inherited']);
|
||||
break;
|
||||
|
||||
case isset($this->class->fieldMappings[$fieldName]['inherited']):
|
||||
$cm = $this->em->getClassMetadata($this->class->fieldMappings[$fieldName]['inherited']);
|
||||
break;
|
||||
|
||||
default:
|
||||
$cm = $this->class;
|
||||
break;
|
||||
}
|
||||
|
||||
$tableName = $cm->getTableName();
|
||||
$quotedTableName = $this->quoteStrategy->getTableName($cm, $this->platform);
|
||||
|
||||
$this->owningTableMap[$fieldName] = $tableName;
|
||||
$this->quotedTableMap[$tableName] = $quotedTableName;
|
||||
|
||||
return $tableName;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function executeInserts()
|
||||
{
|
||||
if (! $this->queuedInserts) {
|
||||
return;
|
||||
}
|
||||
|
||||
$uow = $this->em->getUnitOfWork();
|
||||
$idGenerator = $this->class->idGenerator;
|
||||
$isPostInsertId = $idGenerator->isPostInsertGenerator();
|
||||
$rootClass = $this->class->name !== $this->class->rootEntityName
|
||||
? $this->em->getClassMetadata($this->class->rootEntityName)
|
||||
: $this->class;
|
||||
|
||||
// Prepare statement for the root table
|
||||
$rootPersister = $this->em->getUnitOfWork()->getEntityPersister($rootClass->name);
|
||||
$rootTableName = $rootClass->getTableName();
|
||||
$rootTableStmt = $this->conn->prepare($rootPersister->getInsertSQL());
|
||||
|
||||
// Prepare statements for sub tables.
|
||||
$subTableStmts = [];
|
||||
|
||||
if ($rootClass !== $this->class) {
|
||||
$subTableStmts[$this->class->getTableName()] = $this->conn->prepare($this->getInsertSQL());
|
||||
}
|
||||
|
||||
foreach ($this->class->parentClasses as $parentClassName) {
|
||||
$parentClass = $this->em->getClassMetadata($parentClassName);
|
||||
$parentTableName = $parentClass->getTableName();
|
||||
|
||||
if ($parentClass !== $rootClass) {
|
||||
$parentPersister = $this->em->getUnitOfWork()->getEntityPersister($parentClassName);
|
||||
$subTableStmts[$parentTableName] = $this->conn->prepare($parentPersister->getInsertSQL());
|
||||
}
|
||||
}
|
||||
|
||||
// Execute all inserts. For each entity:
|
||||
// 1) Insert on root table
|
||||
// 2) Insert on sub tables
|
||||
foreach ($this->queuedInserts as $entity) {
|
||||
$insertData = $this->prepareInsertData($entity);
|
||||
|
||||
// Execute insert on root table
|
||||
$paramIndex = 1;
|
||||
|
||||
foreach ($insertData[$rootTableName] as $columnName => $value) {
|
||||
$rootTableStmt->bindValue($paramIndex++, $value, $this->columnTypes[$columnName]);
|
||||
}
|
||||
|
||||
$rootTableStmt->executeStatement();
|
||||
|
||||
if ($isPostInsertId) {
|
||||
$generatedId = $idGenerator->generateId($this->em, $entity);
|
||||
$id = [$this->class->identifier[0] => $generatedId];
|
||||
|
||||
$uow->assignPostInsertId($entity, $generatedId);
|
||||
} else {
|
||||
$id = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
|
||||
}
|
||||
|
||||
// Execute inserts on subtables.
|
||||
// The order doesn't matter because all child tables link to the root table via FK.
|
||||
foreach ($subTableStmts as $tableName => $stmt) {
|
||||
$paramIndex = 1;
|
||||
$data = $insertData[$tableName] ?? [];
|
||||
|
||||
foreach ($id as $idName => $idVal) {
|
||||
$type = $this->columnTypes[$idName] ?? Types::STRING;
|
||||
|
||||
$stmt->bindValue($paramIndex++, $idVal, $type);
|
||||
}
|
||||
|
||||
foreach ($data as $columnName => $value) {
|
||||
if (! isset($id[$columnName])) {
|
||||
$stmt->bindValue($paramIndex++, $value, $this->columnTypes[$columnName]);
|
||||
}
|
||||
}
|
||||
|
||||
$stmt->executeStatement();
|
||||
}
|
||||
|
||||
if ($this->class->requiresFetchAfterChange) {
|
||||
$this->assignDefaultVersionAndUpsertableValues($entity, $id);
|
||||
}
|
||||
}
|
||||
|
||||
$this->queuedInserts = [];
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function update($entity)
|
||||
{
|
||||
$updateData = $this->prepareUpdateData($entity);
|
||||
|
||||
if (! $updateData) {
|
||||
return;
|
||||
}
|
||||
|
||||
$isVersioned = $this->class->isVersioned;
|
||||
|
||||
$versionedClass = $this->getVersionedClassMetadata();
|
||||
$versionedTable = $versionedClass->getTableName();
|
||||
|
||||
foreach ($updateData as $tableName => $data) {
|
||||
$tableName = $this->quotedTableMap[$tableName];
|
||||
$versioned = $isVersioned && $versionedTable === $tableName;
|
||||
|
||||
$this->updateTable($entity, $tableName, $data, $versioned);
|
||||
}
|
||||
|
||||
if ($this->class->requiresFetchAfterChange) {
|
||||
// Make sure the table with the version column is updated even if no columns on that
|
||||
// table were affected.
|
||||
if ($isVersioned && ! isset($updateData[$versionedTable])) {
|
||||
$tableName = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
|
||||
|
||||
$this->updateTable($entity, $tableName, [], true);
|
||||
}
|
||||
|
||||
$identifiers = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
|
||||
|
||||
$this->assignDefaultVersionAndUpsertableValues($entity, $identifiers);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function delete($entity)
|
||||
{
|
||||
$identifier = $this->em->getUnitOfWork()->getEntityIdentifier($entity);
|
||||
$id = array_combine($this->class->getIdentifierColumnNames(), $identifier);
|
||||
$types = $this->getClassIdentifiersTypes($this->class);
|
||||
|
||||
$this->deleteJoinTableRecords($identifier, $types);
|
||||
|
||||
// If the database platform supports FKs, just
|
||||
// delete the row from the root table. Cascades do the rest.
|
||||
if ($this->platform->supportsForeignKeyConstraints()) {
|
||||
$rootClass = $this->em->getClassMetadata($this->class->rootEntityName);
|
||||
$rootTable = $this->quoteStrategy->getTableName($rootClass, $this->platform);
|
||||
$rootTypes = $this->getClassIdentifiersTypes($rootClass);
|
||||
|
||||
return (bool) $this->conn->delete($rootTable, $id, $rootTypes);
|
||||
}
|
||||
|
||||
// Delete from all tables individually, starting from this class' table up to the root table.
|
||||
$rootTable = $this->quoteStrategy->getTableName($this->class, $this->platform);
|
||||
$rootTypes = $this->getClassIdentifiersTypes($this->class);
|
||||
|
||||
$affectedRows = $this->conn->delete($rootTable, $id, $rootTypes);
|
||||
|
||||
foreach ($this->class->parentClasses as $parentClass) {
|
||||
$parentMetadata = $this->em->getClassMetadata($parentClass);
|
||||
$parentTable = $this->quoteStrategy->getTableName($parentMetadata, $this->platform);
|
||||
$parentTypes = $this->getClassIdentifiersTypes($parentMetadata);
|
||||
|
||||
$this->conn->delete($parentTable, $id, $parentTypes);
|
||||
}
|
||||
|
||||
return (bool) $affectedRows;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function getSelectSQL($criteria, $assoc = null, $lockMode = null, $limit = null, $offset = null, ?array $orderBy = null)
|
||||
{
|
||||
$this->switchPersisterContext($offset, $limit);
|
||||
|
||||
$baseTableAlias = $this->getSQLTableAlias($this->class->name);
|
||||
$joinSql = $this->getJoinSql($baseTableAlias);
|
||||
|
||||
if ($assoc !== null && $assoc['type'] === ClassMetadata::MANY_TO_MANY) {
|
||||
$joinSql .= $this->getSelectManyToManyJoinSQL($assoc);
|
||||
}
|
||||
|
||||
$conditionSql = $criteria instanceof Criteria
|
||||
? $this->getSelectConditionCriteriaSQL($criteria)
|
||||
: $this->getSelectConditionSQL($criteria, $assoc);
|
||||
|
||||
$filterSql = $this->generateFilterConditionSQL(
|
||||
$this->em->getClassMetadata($this->class->rootEntityName),
|
||||
$this->getSQLTableAlias($this->class->rootEntityName)
|
||||
);
|
||||
// If the current class in the root entity, add the filters
|
||||
if ($filterSql) {
|
||||
$conditionSql .= $conditionSql
|
||||
? ' AND ' . $filterSql
|
||||
: $filterSql;
|
||||
}
|
||||
|
||||
$orderBySql = '';
|
||||
|
||||
if ($assoc !== null && isset($assoc['orderBy'])) {
|
||||
$orderBy = $assoc['orderBy'];
|
||||
}
|
||||
|
||||
if ($orderBy) {
|
||||
$orderBySql = $this->getOrderBySQL($orderBy, $baseTableAlias);
|
||||
}
|
||||
|
||||
$lockSql = '';
|
||||
|
||||
switch ($lockMode) {
|
||||
case LockMode::PESSIMISTIC_READ:
|
||||
$lockSql = ' ' . $this->getReadLockSQL($this->platform);
|
||||
|
||||
break;
|
||||
|
||||
case LockMode::PESSIMISTIC_WRITE:
|
||||
$lockSql = ' ' . $this->getWriteLockSQL($this->platform);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
$tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
|
||||
$from = ' FROM ' . $tableName . ' ' . $baseTableAlias;
|
||||
$where = $conditionSql !== '' ? ' WHERE ' . $conditionSql : '';
|
||||
$lock = $this->platform->appendLockHint($from, $lockMode ?? LockMode::NONE);
|
||||
$columnList = $this->getSelectColumnsSQL();
|
||||
$query = 'SELECT ' . $columnList
|
||||
. $lock
|
||||
. $joinSql
|
||||
. $where
|
||||
. $orderBySql;
|
||||
|
||||
return $this->platform->modifyLimitQuery($query, $limit, $offset ?? 0) . $lockSql;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function getCountSQL($criteria = [])
|
||||
{
|
||||
$tableName = $this->quoteStrategy->getTableName($this->class, $this->platform);
|
||||
$baseTableAlias = $this->getSQLTableAlias($this->class->name);
|
||||
$joinSql = $this->getJoinSql($baseTableAlias);
|
||||
|
||||
$conditionSql = $criteria instanceof Criteria
|
||||
? $this->getSelectConditionCriteriaSQL($criteria)
|
||||
: $this->getSelectConditionSQL($criteria);
|
||||
|
||||
$filterSql = $this->generateFilterConditionSQL($this->em->getClassMetadata($this->class->rootEntityName), $this->getSQLTableAlias($this->class->rootEntityName));
|
||||
|
||||
if ($filterSql !== '') {
|
||||
$conditionSql = $conditionSql
|
||||
? $conditionSql . ' AND ' . $filterSql
|
||||
: $filterSql;
|
||||
}
|
||||
|
||||
return 'SELECT COUNT(*) '
|
||||
. 'FROM ' . $tableName . ' ' . $baseTableAlias
|
||||
. $joinSql
|
||||
. (empty($conditionSql) ? '' : ' WHERE ' . $conditionSql);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getLockTablesSql($lockMode)
|
||||
{
|
||||
$joinSql = '';
|
||||
$identifierColumns = $this->class->getIdentifierColumnNames();
|
||||
$baseTableAlias = $this->getSQLTableAlias($this->class->name);
|
||||
|
||||
// INNER JOIN parent tables
|
||||
foreach ($this->class->parentClasses as $parentClassName) {
|
||||
$conditions = [];
|
||||
$tableAlias = $this->getSQLTableAlias($parentClassName);
|
||||
$parentClass = $this->em->getClassMetadata($parentClassName);
|
||||
$joinSql .= ' INNER JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
|
||||
|
||||
foreach ($identifierColumns as $idColumn) {
|
||||
$conditions[] = $baseTableAlias . '.' . $idColumn . ' = ' . $tableAlias . '.' . $idColumn;
|
||||
}
|
||||
|
||||
$joinSql .= implode(' AND ', $conditions);
|
||||
}
|
||||
|
||||
return parent::getLockTablesSql($lockMode) . $joinSql;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensure this method is never called. This persister overrides getSelectEntitiesSQL directly.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
protected function getSelectColumnsSQL()
|
||||
{
|
||||
// Create the column list fragment only once
|
||||
if ($this->currentPersisterContext->selectColumnListSql !== null) {
|
||||
return $this->currentPersisterContext->selectColumnListSql;
|
||||
}
|
||||
|
||||
$columnList = [];
|
||||
$discrColumn = $this->class->getDiscriminatorColumn();
|
||||
$discrColumnName = $discrColumn['name'];
|
||||
$discrColumnType = $discrColumn['type'];
|
||||
$baseTableAlias = $this->getSQLTableAlias($this->class->name);
|
||||
$resultColumnName = $this->getSQLResultCasing($this->platform, $discrColumnName);
|
||||
|
||||
$this->currentPersisterContext->rsm->addEntityResult($this->class->name, 'r');
|
||||
$this->currentPersisterContext->rsm->setDiscriminatorColumn('r', $resultColumnName);
|
||||
$this->currentPersisterContext->rsm->addMetaResult('r', $resultColumnName, $discrColumnName, false, $discrColumnType);
|
||||
|
||||
// Add regular columns
|
||||
foreach ($this->class->fieldMappings as $fieldName => $mapping) {
|
||||
$class = isset($mapping['inherited'])
|
||||
? $this->em->getClassMetadata($mapping['inherited'])
|
||||
: $this->class;
|
||||
|
||||
$columnList[] = $this->getSelectColumnSQL($fieldName, $class);
|
||||
}
|
||||
|
||||
// Add foreign key columns
|
||||
foreach ($this->class->associationMappings as $mapping) {
|
||||
if (! $mapping['isOwningSide'] || ! ($mapping['type'] & ClassMetadata::TO_ONE)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$tableAlias = isset($mapping['inherited'])
|
||||
? $this->getSQLTableAlias($mapping['inherited'])
|
||||
: $baseTableAlias;
|
||||
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
|
||||
foreach ($mapping['joinColumns'] as $joinColumn) {
|
||||
$columnList[] = $this->getSelectJoinColumnSQL(
|
||||
$tableAlias,
|
||||
$joinColumn['name'],
|
||||
$this->quoteStrategy->getJoinColumnName($joinColumn, $this->class, $this->platform),
|
||||
PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Add discriminator column (DO NOT ALIAS, see AbstractEntityInheritancePersister#processSQLResult).
|
||||
$tableAlias = $this->class->rootEntityName === $this->class->name
|
||||
? $baseTableAlias
|
||||
: $this->getSQLTableAlias($this->class->rootEntityName);
|
||||
|
||||
$columnList[] = $tableAlias . '.' . $discrColumnName;
|
||||
|
||||
// sub tables
|
||||
foreach ($this->class->subClasses as $subClassName) {
|
||||
$subClass = $this->em->getClassMetadata($subClassName);
|
||||
$tableAlias = $this->getSQLTableAlias($subClassName);
|
||||
|
||||
// Add subclass columns
|
||||
foreach ($subClass->fieldMappings as $fieldName => $mapping) {
|
||||
if (isset($mapping['inherited'])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$columnList[] = $this->getSelectColumnSQL($fieldName, $subClass);
|
||||
}
|
||||
|
||||
// Add join columns (foreign keys)
|
||||
foreach ($subClass->associationMappings as $mapping) {
|
||||
if (
|
||||
! $mapping['isOwningSide']
|
||||
|| ! ($mapping['type'] & ClassMetadata::TO_ONE)
|
||||
|| isset($mapping['inherited'])
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
|
||||
|
||||
foreach ($mapping['joinColumns'] as $joinColumn) {
|
||||
$columnList[] = $this->getSelectJoinColumnSQL(
|
||||
$tableAlias,
|
||||
$joinColumn['name'],
|
||||
$this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform),
|
||||
PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
|
||||
|
||||
return $this->currentPersisterContext->selectColumnListSql;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getInsertColumnList()
|
||||
{
|
||||
// Identifier columns must always come first in the column list of subclasses.
|
||||
$columns = $this->class->parentClasses
|
||||
? $this->class->getIdentifierColumnNames()
|
||||
: [];
|
||||
|
||||
foreach ($this->class->reflFields as $name => $field) {
|
||||
if (
|
||||
isset($this->class->fieldMappings[$name]['inherited'])
|
||||
&& ! isset($this->class->fieldMappings[$name]['id'])
|
||||
|| isset($this->class->associationMappings[$name]['inherited'])
|
||||
|| ($this->class->isVersioned && $this->class->versionField === $name)
|
||||
|| isset($this->class->embeddedClasses[$name])
|
||||
|| isset($this->class->fieldMappings[$name]['notInsertable'])
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (isset($this->class->associationMappings[$name])) {
|
||||
$assoc = $this->class->associationMappings[$name];
|
||||
if ($assoc['type'] & ClassMetadata::TO_ONE && $assoc['isOwningSide']) {
|
||||
foreach ($assoc['targetToSourceKeyColumns'] as $sourceCol) {
|
||||
$columns[] = $sourceCol;
|
||||
}
|
||||
}
|
||||
} elseif (
|
||||
$this->class->name !== $this->class->rootEntityName ||
|
||||
! $this->class->isIdGeneratorIdentity() || $this->class->identifier[0] !== $name
|
||||
) {
|
||||
$columns[] = $this->quoteStrategy->getColumnName($name, $this->class, $this->platform);
|
||||
$this->columnTypes[$name] = $this->class->fieldMappings[$name]['type'];
|
||||
}
|
||||
}
|
||||
|
||||
// Add discriminator column if it is the topmost class.
|
||||
if ($this->class->name === $this->class->rootEntityName) {
|
||||
$columns[] = $this->class->getDiscriminatorColumn()['name'];
|
||||
}
|
||||
|
||||
return $columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function assignDefaultVersionAndUpsertableValues($entity, array $id)
|
||||
{
|
||||
$values = $this->fetchVersionAndNotUpsertableValues($this->getVersionedClassMetadata(), $id);
|
||||
|
||||
foreach ($values as $field => $value) {
|
||||
$value = Type::getType($this->class->fieldMappings[$field]['type'])->convertToPHPValue($value, $this->platform);
|
||||
|
||||
$this->class->setFieldValue($entity, $field, $value);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function fetchVersionAndNotUpsertableValues($versionedClass, array $id)
|
||||
{
|
||||
$columnNames = [];
|
||||
foreach ($this->class->fieldMappings as $key => $column) {
|
||||
$class = null;
|
||||
if ($this->class->isVersioned && $key === $versionedClass->versionField) {
|
||||
$class = $versionedClass;
|
||||
} elseif (isset($column['generated'])) {
|
||||
$class = isset($column['inherited'])
|
||||
? $this->em->getClassMetadata($column['inherited'])
|
||||
: $this->class;
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
|
||||
$columnNames[$key] = $this->getSelectColumnSQL($key, $class);
|
||||
}
|
||||
|
||||
$tableName = $this->quoteStrategy->getTableName($versionedClass, $this->platform);
|
||||
$baseTableAlias = $this->getSQLTableAlias($this->class->name);
|
||||
$joinSql = $this->getJoinSql($baseTableAlias);
|
||||
$identifier = $this->quoteStrategy->getIdentifierColumnNames($versionedClass, $this->platform);
|
||||
foreach ($identifier as $i => $idValue) {
|
||||
$identifier[$i] = $baseTableAlias . '.' . $idValue;
|
||||
}
|
||||
|
||||
$sql = 'SELECT ' . implode(', ', $columnNames)
|
||||
. ' FROM ' . $tableName . ' ' . $baseTableAlias
|
||||
. $joinSql
|
||||
. ' WHERE ' . implode(' = ? AND ', $identifier) . ' = ?';
|
||||
|
||||
$flatId = $this->identifierFlattener->flattenIdentifier($versionedClass, $id);
|
||||
$values = $this->conn->fetchNumeric(
|
||||
$sql,
|
||||
array_values($flatId),
|
||||
$this->extractIdentifierTypes($id, $versionedClass)
|
||||
);
|
||||
|
||||
if ($values === false) {
|
||||
throw new LengthException('Unexpected empty result for database query.');
|
||||
}
|
||||
|
||||
$values = array_combine(array_keys($columnNames), $values);
|
||||
|
||||
if (! $values) {
|
||||
throw new LengthException('Unexpected number of database columns.');
|
||||
}
|
||||
|
||||
return $values;
|
||||
}
|
||||
|
||||
private function getJoinSql(string $baseTableAlias): string
|
||||
{
|
||||
$joinSql = '';
|
||||
$identifierColumn = $this->class->getIdentifierColumnNames();
|
||||
|
||||
// INNER JOIN parent tables
|
||||
foreach ($this->class->parentClasses as $parentClassName) {
|
||||
$conditions = [];
|
||||
$parentClass = $this->em->getClassMetadata($parentClassName);
|
||||
$tableAlias = $this->getSQLTableAlias($parentClassName);
|
||||
$joinSql .= ' INNER JOIN ' . $this->quoteStrategy->getTableName($parentClass, $this->platform) . ' ' . $tableAlias . ' ON ';
|
||||
|
||||
foreach ($identifierColumn as $idColumn) {
|
||||
$conditions[] = $baseTableAlias . '.' . $idColumn . ' = ' . $tableAlias . '.' . $idColumn;
|
||||
}
|
||||
|
||||
$joinSql .= implode(' AND ', $conditions);
|
||||
}
|
||||
|
||||
// OUTER JOIN sub tables
|
||||
foreach ($this->class->subClasses as $subClassName) {
|
||||
$conditions = [];
|
||||
$subClass = $this->em->getClassMetadata($subClassName);
|
||||
$tableAlias = $this->getSQLTableAlias($subClassName);
|
||||
$joinSql .= ' LEFT JOIN ' . $this->quoteStrategy->getTableName($subClass, $this->platform) . ' ' . $tableAlias . ' ON ';
|
||||
|
||||
foreach ($identifierColumn as $idColumn) {
|
||||
$conditions[] = $baseTableAlias . '.' . $idColumn . ' = ' . $tableAlias . '.' . $idColumn;
|
||||
}
|
||||
|
||||
$joinSql .= implode(' AND ', $conditions);
|
||||
}
|
||||
|
||||
return $joinSql;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,179 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Entity;
|
||||
|
||||
use Doctrine\Common\Collections\Criteria;
|
||||
use Doctrine\ORM\Internal\SQLResultCasing;
|
||||
use Doctrine\ORM\Mapping\ClassMetadata;
|
||||
use Doctrine\ORM\Utility\PersisterHelper;
|
||||
|
||||
use function array_flip;
|
||||
use function array_intersect;
|
||||
use function array_map;
|
||||
use function array_unshift;
|
||||
use function implode;
|
||||
|
||||
/**
|
||||
* Persister for entities that participate in a hierarchy mapped with the
|
||||
* SINGLE_TABLE strategy.
|
||||
*
|
||||
* @link https://martinfowler.com/eaaCatalog/singleTableInheritance.html
|
||||
*/
|
||||
class SingleTablePersister extends AbstractEntityInheritancePersister
|
||||
{
|
||||
use SQLResultCasing;
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getDiscriminatorColumnTableName()
|
||||
{
|
||||
return $this->class->getTableName();
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getSelectColumnsSQL()
|
||||
{
|
||||
if ($this->currentPersisterContext->selectColumnListSql !== null) {
|
||||
return $this->currentPersisterContext->selectColumnListSql;
|
||||
}
|
||||
|
||||
$columnList[] = parent::getSelectColumnsSQL();
|
||||
|
||||
$rootClass = $this->em->getClassMetadata($this->class->rootEntityName);
|
||||
$tableAlias = $this->getSQLTableAlias($rootClass->name);
|
||||
|
||||
// Append discriminator column
|
||||
$discrColumn = $this->class->getDiscriminatorColumn();
|
||||
$discrColumnName = $discrColumn['name'];
|
||||
$discrColumnType = $discrColumn['type'];
|
||||
|
||||
$columnList[] = $tableAlias . '.' . $discrColumnName;
|
||||
|
||||
$resultColumnName = $this->getSQLResultCasing($this->platform, $discrColumnName);
|
||||
|
||||
$this->currentPersisterContext->rsm->setDiscriminatorColumn('r', $resultColumnName);
|
||||
$this->currentPersisterContext->rsm->addMetaResult('r', $resultColumnName, $discrColumnName, false, $discrColumnType);
|
||||
|
||||
// Append subclass columns
|
||||
foreach ($this->class->subClasses as $subClassName) {
|
||||
$subClass = $this->em->getClassMetadata($subClassName);
|
||||
|
||||
// Regular columns
|
||||
foreach ($subClass->fieldMappings as $fieldName => $mapping) {
|
||||
if (isset($mapping['inherited'])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$columnList[] = $this->getSelectColumnSQL($fieldName, $subClass);
|
||||
}
|
||||
|
||||
// Foreign key columns
|
||||
foreach ($subClass->associationMappings as $assoc) {
|
||||
if (! $assoc['isOwningSide'] || ! ($assoc['type'] & ClassMetadata::TO_ONE) || isset($assoc['inherited'])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$targetClass = $this->em->getClassMetadata($assoc['targetEntity']);
|
||||
|
||||
foreach ($assoc['joinColumns'] as $joinColumn) {
|
||||
$columnList[] = $this->getSelectJoinColumnSQL(
|
||||
$tableAlias,
|
||||
$joinColumn['name'],
|
||||
$this->quoteStrategy->getJoinColumnName($joinColumn, $subClass, $this->platform),
|
||||
PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$this->currentPersisterContext->selectColumnListSql = implode(', ', $columnList);
|
||||
|
||||
return $this->currentPersisterContext->selectColumnListSql;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getInsertColumnList()
|
||||
{
|
||||
$columns = parent::getInsertColumnList();
|
||||
|
||||
// Add discriminator column to the INSERT SQL
|
||||
$columns[] = $this->class->getDiscriminatorColumn()['name'];
|
||||
|
||||
return $columns;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getSQLTableAlias($className, $assocName = '')
|
||||
{
|
||||
return parent::getSQLTableAlias($this->class->rootEntityName, $assocName);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getSelectConditionSQL(array $criteria, $assoc = null)
|
||||
{
|
||||
$conditionSql = parent::getSelectConditionSQL($criteria, $assoc);
|
||||
|
||||
if ($conditionSql) {
|
||||
$conditionSql .= ' AND ';
|
||||
}
|
||||
|
||||
return $conditionSql . $this->getSelectConditionDiscriminatorValueSQL();
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function getSelectConditionCriteriaSQL(Criteria $criteria)
|
||||
{
|
||||
$conditionSql = parent::getSelectConditionCriteriaSQL($criteria);
|
||||
|
||||
if ($conditionSql) {
|
||||
$conditionSql .= ' AND ';
|
||||
}
|
||||
|
||||
return $conditionSql . $this->getSelectConditionDiscriminatorValueSQL();
|
||||
}
|
||||
|
||||
/** @return string */
|
||||
protected function getSelectConditionDiscriminatorValueSQL()
|
||||
{
|
||||
$values = array_map(
|
||||
[$this->conn, 'quote'],
|
||||
array_flip(array_intersect($this->class->discriminatorMap, $this->class->subClasses))
|
||||
);
|
||||
|
||||
if ($this->class->discriminatorValue !== null) { // discriminators can be 0
|
||||
array_unshift($values, $this->conn->quote($this->class->discriminatorValue));
|
||||
}
|
||||
|
||||
$discColumnName = $this->class->getDiscriminatorColumn()['name'];
|
||||
|
||||
$values = implode(', ', $values);
|
||||
$tableAlias = $this->getSQLTableAlias($this->class->name);
|
||||
|
||||
return $tableAlias . '.' . $discColumnName . ' IN (' . $values . ')';
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
|
||||
{
|
||||
// Ensure that the filters are applied to the root entity of the inheritance tree
|
||||
$targetEntity = $this->em->getClassMetadata($targetEntity->rootEntityName);
|
||||
// we don't care about the $targetTableAlias, in a STI there is only one table.
|
||||
|
||||
return parent::generateFilterConditionSQL($targetEntity, $targetTableAlias);
|
||||
}
|
||||
}
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Exception;
|
||||
|
||||
use Doctrine\ORM\Exception\PersisterException;
|
||||
|
||||
class CantUseInOperatorOnCompositeKeys extends PersisterException
|
||||
{
|
||||
public static function create(): self
|
||||
{
|
||||
return new self("Can't use IN operator on entities that have composite keys.");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Exception;
|
||||
|
||||
use Doctrine\ORM\Exception\PersisterException;
|
||||
|
||||
class InvalidOrientation extends PersisterException
|
||||
{
|
||||
public static function fromClassNameAndField(string $className, string $field): self
|
||||
{
|
||||
return new self('Invalid order by orientation specified for ' . $className . '#' . $field);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters\Exception;
|
||||
|
||||
use Doctrine\ORM\Exception\PersisterException;
|
||||
|
||||
use function sprintf;
|
||||
|
||||
final class UnrecognizedField extends PersisterException
|
||||
{
|
||||
/** @deprecated Use {@see byFullyQualifiedName()} instead. */
|
||||
public static function byName(string $field): self
|
||||
{
|
||||
return new self(sprintf('Unrecognized field: %s', $field));
|
||||
}
|
||||
|
||||
/** @param class-string $className */
|
||||
public static function byFullyQualifiedName(string $className, string $field): self
|
||||
{
|
||||
return new self(sprintf('Unrecognized field: %s::$%s', $className, $field));
|
||||
}
|
||||
}
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters;
|
||||
|
||||
use Doctrine\ORM\Exception\PersisterException;
|
||||
|
||||
use function sprintf;
|
||||
|
||||
final class MatchingAssociationFieldRequiresObject extends PersisterException
|
||||
{
|
||||
public static function fromClassAndAssociation(string $class, string $associationName): self
|
||||
{
|
||||
return new self(sprintf(
|
||||
'Cannot match on %s::%s with a non-object value. Matching objects by id is ' .
|
||||
'not compatible with matching on an in-memory collection, which compares objects by reference.',
|
||||
$class,
|
||||
$associationName
|
||||
));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters;
|
||||
|
||||
use Doctrine\ORM\Exception\ORMException;
|
||||
|
||||
use function sprintf;
|
||||
|
||||
class PersisterException extends ORMException
|
||||
{
|
||||
/**
|
||||
* @param string $class
|
||||
* @param string $associationName
|
||||
*
|
||||
* @return PersisterException
|
||||
*/
|
||||
public static function matchingAssocationFieldRequiresObject($class, $associationName)
|
||||
{
|
||||
return new self(sprintf(
|
||||
'Cannot match on %s::%s with a non-object value. Matching objects by id is ' .
|
||||
'not compatible with matching on an in-memory collection, which compares objects by reference.',
|
||||
$class,
|
||||
$associationName
|
||||
));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters;
|
||||
|
||||
use Doctrine\Common\Collections\Expr\Comparison;
|
||||
use Doctrine\Common\Collections\Expr\CompositeExpression;
|
||||
use Doctrine\Common\Collections\Expr\ExpressionVisitor;
|
||||
use Doctrine\Common\Collections\Expr\Value;
|
||||
use Doctrine\ORM\Mapping\ClassMetadata;
|
||||
use Doctrine\ORM\Persisters\Entity\BasicEntityPersister;
|
||||
use RuntimeException;
|
||||
|
||||
use function defined;
|
||||
use function implode;
|
||||
use function in_array;
|
||||
use function is_object;
|
||||
|
||||
/**
|
||||
* Visit Expressions and generate SQL WHERE conditions from them.
|
||||
*/
|
||||
class SqlExpressionVisitor extends ExpressionVisitor
|
||||
{
|
||||
/** @var BasicEntityPersister */
|
||||
private $persister;
|
||||
|
||||
/** @var ClassMetadata */
|
||||
private $classMetadata;
|
||||
|
||||
public function __construct(BasicEntityPersister $persister, ClassMetadata $classMetadata)
|
||||
{
|
||||
$this->persister = $persister;
|
||||
$this->classMetadata = $classMetadata;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a comparison expression into the target query language output.
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
public function walkComparison(Comparison $comparison)
|
||||
{
|
||||
$field = $comparison->getField();
|
||||
$value = $comparison->getValue()->getValue(); // shortcut for walkValue()
|
||||
|
||||
if (
|
||||
isset($this->classMetadata->associationMappings[$field]) &&
|
||||
$value !== null &&
|
||||
! is_object($value) &&
|
||||
! in_array($comparison->getOperator(), [Comparison::IN, Comparison::NIN], true)
|
||||
) {
|
||||
throw MatchingAssociationFieldRequiresObject::fromClassAndAssociation(
|
||||
$this->classMetadata->name,
|
||||
$field
|
||||
);
|
||||
}
|
||||
|
||||
return $this->persister->getSelectConditionStatementSQL($field, $value, null, $comparison->getOperator());
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a composite expression into the target query language output.
|
||||
*
|
||||
* @return string
|
||||
*
|
||||
* @throws RuntimeException
|
||||
*/
|
||||
public function walkCompositeExpression(CompositeExpression $expr)
|
||||
{
|
||||
$expressionList = [];
|
||||
|
||||
foreach ($expr->getExpressionList() as $child) {
|
||||
$expressionList[] = $this->dispatch($child);
|
||||
}
|
||||
|
||||
switch ($expr->getType()) {
|
||||
case CompositeExpression::TYPE_AND:
|
||||
return '(' . implode(' AND ', $expressionList) . ')';
|
||||
|
||||
case CompositeExpression::TYPE_OR:
|
||||
return '(' . implode(' OR ', $expressionList) . ')';
|
||||
|
||||
default:
|
||||
// Multiversion support for `doctrine/collections` before and after v2.1.0
|
||||
if (defined(CompositeExpression::class . '::TYPE_NOT') && $expr->getType() === CompositeExpression::TYPE_NOT) {
|
||||
return 'NOT (' . $expressionList[0] . ')';
|
||||
}
|
||||
|
||||
throw new RuntimeException('Unknown composite ' . $expr->getType());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a value expression into the target query language part.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function walkValue(Value $value)
|
||||
{
|
||||
return '?';
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Doctrine\ORM\Persisters;
|
||||
|
||||
use Doctrine\Common\Collections\Expr\Comparison;
|
||||
use Doctrine\Common\Collections\Expr\CompositeExpression;
|
||||
use Doctrine\Common\Collections\Expr\ExpressionVisitor;
|
||||
use Doctrine\Common\Collections\Expr\Value;
|
||||
|
||||
/**
|
||||
* Extract the values from a criteria/expression
|
||||
*/
|
||||
class SqlValueVisitor extends ExpressionVisitor
|
||||
{
|
||||
/** @var mixed[] */
|
||||
private $values = [];
|
||||
|
||||
/** @var mixed[][] */
|
||||
private $types = [];
|
||||
|
||||
/**
|
||||
* Converts a comparison expression into the target query language output.
|
||||
*
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function walkComparison(Comparison $comparison)
|
||||
{
|
||||
$value = $this->getValueFromComparison($comparison);
|
||||
|
||||
$this->values[] = $value;
|
||||
$this->types[] = [$comparison->getField(), $value, $comparison->getOperator()];
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a composite expression into the target query language output.
|
||||
*
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function walkCompositeExpression(CompositeExpression $expr)
|
||||
{
|
||||
foreach ($expr->getExpressionList() as $child) {
|
||||
$this->dispatch($child);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a value expression into the target query language part.
|
||||
*
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public function walkValue(Value $value)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the Parameters and Types necessary for matching the last visited expression.
|
||||
*
|
||||
* @return mixed[][]
|
||||
* @psalm-return array{0: array, 1: array<array<mixed>>}
|
||||
*/
|
||||
public function getParamsAndTypes()
|
||||
{
|
||||
return [$this->values, $this->types];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the value from a Comparison. In case of a CONTAINS comparison,
|
||||
* the value is wrapped in %-signs, because it will be used in a LIKE clause.
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
protected function getValueFromComparison(Comparison $comparison)
|
||||
{
|
||||
$value = $comparison->getValue()->getValue();
|
||||
|
||||
switch ($comparison->getOperator()) {
|
||||
case Comparison::CONTAINS:
|
||||
return '%' . $value . '%';
|
||||
|
||||
case Comparison::STARTS_WITH:
|
||||
return $value . '%';
|
||||
|
||||
case Comparison::ENDS_WITH:
|
||||
return '%' . $value;
|
||||
|
||||
default:
|
||||
return $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user