ManyToManyPersister::getDeleteRowSQLParameters() - Code Metrics - Inspection of "More optimizations and preparation for ClassMetada..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed
Push — develop ( 082d66...6f26e1 )

by Guilherme
created 2017-08-05 18:41 UTC
ManyToManyPersister::getDeleteRowSQLParameters() A

↳ Parent: ManyToManyPersister
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	1
CRAP Score	1
Importance

Changes
Metric	Value
dl	0
loc	4
ccs	1
cts	1
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	2
crap	1
<?php

declare(strict_types=1);

namespace Doctrine\ORM\Persisters\Collection;

use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\Mapping\AssociationMetadata;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\FieldMetadata;
use Doctrine\ORM\Mapping\JoinColumnMetadata;
use Doctrine\ORM\Mapping\ManyToManyAssociationMetadata;
use Doctrine\ORM\Mapping\ToManyAssociationMetadata;
use Doctrine\ORM\Mapping\ToOneAssociationMetadata;
use Doctrine\ORM\Persisters\SqlValueVisitor;
use Doctrine\ORM\PersistentCollection;
use Doctrine\ORM\Query;
use Doctrine\ORM\Utility\PersisterHelper;

/**
 * Persister for many-to-many collections.
 *
 * @author  Roman Borschel <[email protected]>
 * @author  Guilherme Blanco <[email protected]>
 * @author  Alexander <[email protected]>
 * @since   2.0
 */
class ManyToManyPersister extends AbstractCollectionPersister
{
    /**
     * {@inheritdoc}
     */
    public function delete(PersistentCollection $collection)
    {
        $association = $collection->getMapping();

        if (! $association->isOwningSide()) {
            return; // ignore inverse side
        }

        $class     = $this->em->getClassMetadata($association->getSourceEntity());
        $joinTable = $association->getJoinTable();
        $types     = [];

        foreach ($joinTable->getJoinColumns() as $joinColumn) {
            /** @var JoinColumnMetadata $joinColumn */
            $referencedColumnName = $joinColumn->getReferencedColumnName();

            if (! $joinColumn->getType()) {
                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $class, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $types[] = $joinColumn->getType();
        }

        $sql    = $this->getDeleteSQL($collection);
        $params = $this->getDeleteSQLParameters($collection);

        $this->conn->executeUpdate($sql, $params, $types);
    }

    /**
     * {@inheritdoc}
     */
    public function update(PersistentCollection $collection)
    {
        $association = $collection->getMapping();

        if (! $association->isOwningSide()) {
            return; // ignore inverse side
        }

        list($deleteSql, $deleteTypes) = $this->getDeleteRowSQL($collection);
        list($insertSql, $insertTypes) = $this->getInsertRowSQL($collection);

        foreach ($collection->getDeleteDiff() as $element) {
            $this->conn->executeUpdate(
                $deleteSql,
                $this->getDeleteRowSQLParameters($collection, $element),
                $deleteTypes
            );
        }

        foreach ($collection->getInsertDiff() as $element) {
            $this->conn->executeUpdate(
                $insertSql,
                $this->getInsertRowSQLParameters($collection, $element),
                $insertTypes
            );
        }
    }

    /**
     * {@inheritdoc}
     */
    public function get(PersistentCollection $collection, $index)
    {
        $association = $collection->getMapping();

        if (! ($association instanceof ToManyAssociationMetadata && $association->getIndexedBy())) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            throw new \BadMethodCallException("Selecting a collection by index is only supported on indexed collections.");
        }

        $persister = $this->uow->getEntityPersister($association->getTargetEntity());
        $mappedKey = $association->isOwningSide()
            ? $association->getInversedBy()
            : $association->getMappedBy()
        ;

        $criteria  = [
            $mappedKey                   => $collection->getOwner(),
            $association->getIndexedBy() => $index,
        ];

        return $persister->load($criteria, null, $association, [], 0, 1);
    }

    /**
     * {@inheritdoc}
     */
    public function count(PersistentCollection $collection)
    {
        $conditions        = [];
        $params            = [];
        $types             = [];
        $association       = $collection->getMapping();
        $identifier        = $this->uow->getEntityIdentifier($collection->getOwner());
        $sourceClass       = $this->em->getClassMetadata($association->getSourceEntity());
        $targetClass       = $this->em->getClassMetadata($association->getTargetEntity());
        $owningAssociation = ! $association->isOwningSide()
            ? $targetClass->getProperty($association->getMappedBy())

            : $association
        ;

        $joinTable      = $owningAssociation->getJoinTable();
        $joinTableName  = $joinTable->getQuotedQualifiedName($this->platform);
        $joinColumns    = $association->isOwningSide()
            ? $joinTable->getJoinColumns()
            : $joinTable->getInverseJoinColumns()
        ;

        foreach ($joinColumns as $joinColumn) {

            /** @var JoinColumnMetadata $joinColumn */
            $quotedColumnName     = $this->platform->quoteIdentifier($joinColumn->getColumnName());
            $referencedColumnName = $joinColumn->getReferencedColumnName();

            if (! $joinColumn->getType()) {
                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $sourceClass, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $conditions[]   = sprintf('t.%s = ?', $quotedColumnName);
            $params[]       = $identifier[$sourceClass->fieldNames[$referencedColumnName]];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $types[]        = $joinColumn->getType();
        }

        list($joinTargetEntitySQL, $filterSql) = $this->getFilterSql($association);


        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 = $targetClass->table->getQuotedQualifiedName($this->platform);
            $targetJoinSql   = ' JOIN ' . $targetTableName . ' te'
                . ' ON' . implode(' AND ', $this->getOnConditionSQL($association));

            // And criteria conditions needs to be added
            $persister    = $this->uow->getEntityPersister($targetClass->getClassName());
            $visitor      = new SqlExpressionVisitor($persister, $targetClass);
            $conditions[] = $visitor->dispatch($expression);

            $joinTargetEntitySQL = $targetJoinSql . $joinTargetEntitySQL;
        }*/

        $sql = 'SELECT COUNT(*)'
            . ' FROM ' . $joinTableName . ' t'
            . $joinTargetEntitySQL
            . ' WHERE ' . implode(' AND ', $conditions);

        return $this->conn->fetchColumn($sql, $params, 0, $types);

    }

    /**
     * {@inheritDoc}
     */
    public function slice(PersistentCollection $collection, $offset, $length = null)
    {
        $association = $collection->getMapping();
        $persister   = $this->uow->getEntityPersister($association->getTargetEntity());

        return $persister->getManyToManyCollection($association, $collection->getOwner(), $offset, $length);

    }
    /**
     * {@inheritdoc}
     */
    public function containsKey(PersistentCollection $collection, $key)
    {
        $association = $collection->getMapping();

        if (! ($association instanceof ToManyAssociationMetadata && $association->getIndexedBy())) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            throw new \BadMethodCallException("Selecting a collection by index is only supported on indexed collections.");
        }

        list($quotedJoinTable, $whereClauses, $params, $types) = $this->getJoinTableRestrictionsWithKey($collection, $key, true);

        $sql = 'SELECT 1 FROM ' . $quotedJoinTable . ' WHERE ' . implode(' AND ', $whereClauses);

        return (bool) $this->conn->fetchColumn($sql, $params, 0, $types);
    }

    /**
     * {@inheritDoc}
     */
    public function contains(PersistentCollection $collection, $element)
    {
        if ( ! $this->isValidEntityState($element)) {
            return false;
        }

        list($quotedJoinTable, $whereClauses, $params, $types) = $this->getJoinTableRestrictions($collection, $element, true);

        $sql = 'SELECT 1 FROM ' . $quotedJoinTable . ' WHERE ' . implode(' AND ', $whereClauses);

        return (bool) $this->conn->fetchColumn($sql, $params, 0, $types);
    }

    /**
     * {@inheritDoc}
     */
    public function removeElement(PersistentCollection $collection, $element)
    {
        if ( ! $this->isValidEntityState($element)) {
            return false;
        }

        list($quotedJoinTable, $whereClauses, $params, $types) = $this->getJoinTableRestrictions($collection, $element, false);

        $sql = 'DELETE FROM ' . $quotedJoinTable . ' WHERE ' . implode(' AND ', $whereClauses);

        return (bool) $this->conn->executeUpdate($sql, $params, $types);
    }

    /**
     * {@inheritDoc}
     */
    public function loadCriteria(PersistentCollection $collection, Criteria $criteria)
    {
        $association   = $collection->getMapping();
        $owner         = $collection->getOwner();
        $ownerMetadata = $this->em->getClassMetadata(get_class($owner));
        $identifier    = $this->uow->getEntityIdentifier($owner);
        $targetClass   = $this->em->getClassMetadata($association->getTargetEntity());
        $onConditions  = $this->getOnConditionSQL($association);

        $whereClauses  = $params = $types = [];

        if (! $association->isOwningSide()) {
            $association = $targetClass->getProperty($association->getMappedBy());

            $joinColumns = $association->getJoinTable()->getInverseJoinColumns();
        } else {
            $joinColumns = $association->getJoinTable()->getJoinColumns();
        }

        foreach ($joinColumns as $joinColumn) {

            /** @var JoinColumnMetadata $joinColumn */
            $quotedColumnName     = $this->platform->quoteIdentifier($joinColumn->getColumnName());
            $referencedColumnName = $joinColumn->getReferencedColumnName();

            if (! $joinColumn->getType()) {
                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $ownerMetadata, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $whereClauses[] = sprintf('t.%s = ?', $quotedColumnName);
            $params[] = $identifier[$ownerMetadata->fieldNames[$referencedColumnName]];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $types[] = $joinColumn->getType();
        }

        $parameters = $this->expandCriteriaParameters($criteria);

        foreach ($parameters as $parameter) {
            list($name, $value) = $parameter;

            $property   = $targetClass->getProperty($name);

            $columnName = $this->platform->quoteIdentifier($property->getColumnName());

            $whereClauses[] = sprintf('te.%s = ?', $columnName);
            $params[]       = $value;
            $types[]        = $property->getType();
        }

        $tableName        = $targetClass->table->getQuotedQualifiedName($this->platform);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $joinTableName    = $association->getJoinTable()->getQuotedQualifiedName($this->platform);
        $resultSetMapping = new Query\ResultSetMappingBuilder($this->em);

        $resultSetMapping->addRootEntityFromClassMetadata($targetClass->getClassName(), 'te');


        $sql = 'SELECT ' . $resultSetMapping->generateSelectClause()
            . ' FROM ' . $tableName . ' te'
            . ' JOIN ' . $joinTableName . ' t ON'
            . implode(' AND ', $onConditions)
            . ' WHERE ' . implode(' AND ', $whereClauses);

        $sql .= $this->getOrderingSql($criteria, $targetClass);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $sql .= $this->getLimitSql($criteria);

        $stmt = $this->conn->executeQuery($sql, $params, $types);

        return $this->em->newHydrator(Query::HYDRATE_OBJECT)->hydrateAll($stmt, $resultSetMapping);
    }

    /**
     * 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 ManyToManyAssociationMetadata $association
     *
     * @return string[] ordered tuple:
     *                   - JOIN condition to add to the SQL
     *                   - WHERE condition to add to the SQL
     */
    public function getFilterSql(ManyToManyAssociationMetadata $association)
    {
        $targetClass = $this->em->getClassMetadata($association->getTargetEntity());
        $rootClass   = $this->em->getClassMetadata($targetClass->getRootClassName());

        $filterSql   = $this->generateFilterConditionSQL($rootClass, 'te');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        if ('' === $filterSql) {
            return ['', ''];
        }

        // A join is needed if there is filtering on the target entity
        $tableName = $rootClass->table->getQuotedQualifiedName($this->platform);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $joinSql   = ' JOIN ' . $tableName . ' te'
            . ' ON' . implode(' AND ', $this->getOnConditionSQL($association));

        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) {

            if ($filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias)) {
                $filterClauses[] = '(' . $filterExpr . ')';
            }
        }

        if (! $filterClauses) {

            return '';
        }

        $filterSql = implode(' AND ', $filterClauses);

        return count($filterClauses) > 1
            ? '(' . $filterSql . ')'
            : $filterSql
        ;
    }

    /**
     * Generate ON condition
     *
     * @param ManyToManyAssociationMetadata $association
     *
     * @return array
     */
    protected function getOnConditionSQL(ManyToManyAssociationMetadata $association)
    {
        $targetClass       = $this->em->getClassMetadata($association->getTargetEntity());
        $owningAssociation = ! $association->isOwningSide()
            ? $targetClass->getProperty($association->getMappedBy())

            : $association;

        $joinTable   = $owningAssociation->getJoinTable();
        $joinColumns = $association->isOwningSide()
            ? $joinTable->getInverseJoinColumns()
            : $joinTable->getJoinColumns()
        ;

        $conditions = [];

        foreach ($joinColumns as $joinColumn) {

            $quotedColumnName           = $this->platform->quoteIdentifier($joinColumn->getColumnName());
            $quotedReferencedColumnName = $this->platform->quoteIdentifier($joinColumn->getReferencedColumnName());

            $conditions[] = ' t.' . $quotedColumnName . ' = ' . 'te.' . $quotedReferencedColumnName;
        }

        return $conditions;
    }

    /**
     * {@inheritdoc}
     *
     * @override
     */
    protected function getDeleteSQL(PersistentCollection $collection)
    {
        $association   = $collection->getMapping();
        $joinTable     = $association->getJoinTable();
        $joinTableName = $joinTable->getQuotedQualifiedName($this->platform);
        $columns       = [];

        foreach ($joinTable->getJoinColumns() as $joinColumn) {
            $columns[] = $this->platform->quoteIdentifier($joinColumn->getColumnName());
        }

        return 'DELETE FROM ' . $joinTableName . ' WHERE ' . implode(' = ? AND ', $columns) . ' = ?';
    }

    /**
     * {@inheritdoc}
     *
     * Internal note: Order of the parameters must be the same as the order of the columns in getDeleteSql.
     * @override
     */
    protected function getDeleteSQLParameters(PersistentCollection $collection)
    {
        $association = $collection->getMapping();
        $identifier  = $this->uow->getEntityIdentifier($collection->getOwner());
        $joinTable   = $association->getJoinTable();
        $joinColumns = $joinTable->getJoinColumns();

        // Optimization for single column identifier
        if (count($joinColumns) === 1) {
            return [reset($identifier)];
        }

        // Composite identifier
        $sourceClass = $this->em->getClassMetadata($association->getSourceEntity());
        $params      = [];

        foreach ($joinColumns as $joinColumn) {
            $params[] = $identifier[$sourceClass->fieldNames[$joinColumn->getReferencedColumnName()]];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }

        return $params;
    }

    /**
     * Gets the SQL statement used for deleting a row from the collection.
     *
     * @param \Doctrine\ORM\PersistentCollection $collection
     *
     * @return string[]|string[][] ordered tuple containing the SQL to be executed and an array
     *                             of types for bound parameters
     */
    protected function getDeleteRowSQL(PersistentCollection $collection)
    {
        $association = $collection->getMapping();
        $class       = $this->em->getClassMetadata($association->getSourceEntity());
        $targetClass = $this->em->getClassMetadata($association->getTargetEntity());
        $columns     = [];
        $types       = [];

        $joinTable     = $association->getJoinTable();
        $joinTableName = $joinTable->getQuotedQualifiedName($this->platform);

        foreach ($joinTable->getJoinColumns() as $joinColumn) {
            /** @var JoinColumnMetadata $joinColumn */
            $quotedColumnName     = $this->platform->quoteIdentifier($joinColumn->getColumnName());
            $referencedColumnName = $joinColumn->getReferencedColumnName();

            if (! $joinColumn->getType()) {
                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $class, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $columns[] = $quotedColumnName;
            $types[]   = $joinColumn->getType();
        }

        foreach ($joinTable->getInverseJoinColumns() as $joinColumn) {
            /** @var JoinColumnMetadata $joinColumn */
            $quotedColumnName     = $this->platform->quoteIdentifier($joinColumn->getColumnName());
            $referencedColumnName = $joinColumn->getReferencedColumnName();

            if (! $joinColumn->getType()) {
                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $targetClass, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $columns[] = $quotedColumnName;
            $types[]   = $joinColumn->getType();
        }

        return [
            sprintf('DELETE FROM %s WHERE %s = ?', $joinTableName, 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 \Doctrine\ORM\PersistentCollection $collection
     * @param mixed                              $element
     *
     * @return array
     */
    protected function getDeleteRowSQLParameters(PersistentCollection $collection, $element)
    {
        return $this->collectJoinTableColumnParameters($collection, $element);
    }

    /**
     * Gets the SQL statement used for inserting a row in the collection.
     *
     * @param \Doctrine\ORM\PersistentCollection $collection
     *
     * @return string[]|string[][] ordered tuple containing the SQL to be executed and an array
     *                             of types for bound parameters
     */
    protected function getInsertRowSQL(PersistentCollection $collection)
    {
        $association = $collection->getMapping();
        $class       = $this->em->getClassMetadata($association->getSourceEntity());
        $targetClass = $this->em->getClassMetadata($association->getTargetEntity());
        $columns     = [];
        $types       = [];

        $joinTable     = $association->getJoinTable();
        $joinTableName = $joinTable->getQuotedQualifiedName($this->platform);

        foreach ($joinTable->getJoinColumns() as $joinColumn) {
            /** @var JoinColumnMetadata $joinColumn */
            $quotedColumnName     = $this->platform->quoteIdentifier($joinColumn->getColumnName());
            $referencedColumnName = $joinColumn->getReferencedColumnName();

            if (! $joinColumn->getType()) {
                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $class, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $columns[] = $quotedColumnName;
            $types[]   = $joinColumn->getType();
        }

        foreach ($joinTable->getInverseJoinColumns() as $joinColumn) {
            /** @var JoinColumnMetadata $joinColumn */
            $quotedColumnName     = $this->platform->quoteIdentifier($joinColumn->getColumnName());
            $referencedColumnName = $joinColumn->getReferencedColumnName();

            if (! $joinColumn->getType()) {
                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $targetClass, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $columns[] = $quotedColumnName;
            $types[]   = $joinColumn->getType();
        }

        $columnNamesAsString  = implode(', ', $columns);
        $columnValuesAsString = implode(', ', array_fill(0, count($columns), '?'));

        return [
            sprintf('INSERT INTO %s (%s) VALUES (%s)', $joinTableName, $columnNamesAsString, $columnValuesAsString),
            $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 \Doctrine\ORM\PersistentCollection $collection
     * @param mixed                              $element
     *
     * @return array
     */
    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.
     *
     * @param \Doctrine\ORM\PersistentCollection $collection
     * @param object                             $element
     *
     * @return array
     */
    private function collectJoinTableColumnParameters(PersistentCollection $collection, $element)
    {
        $params           = [];
        $association      = $collection->getMapping();
        $owningClass      = $this->em->getClassMetadata(get_class($collection->getOwner()));
        $targetClass      = $collection->getTypeClass();
        $owningIdentifier = $this->uow->getEntityIdentifier($collection->getOwner());
        $targetIdentifier = $this->uow->getEntityIdentifier($element);
        $joinTable        = $association->getJoinTable();

        foreach ($joinTable->getJoinColumns() as $joinColumn) {
            $fieldName = $owningClass->fieldNames[$joinColumn->getReferencedColumnName()];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

            $params[] = $owningIdentifier[$fieldName];
        }

        foreach ($joinTable->getInverseJoinColumns() as $joinColumn) {
            $fieldName = $targetClass->fieldNames[$joinColumn->getReferencedColumnName()];

            $params[] = $targetIdentifier[$fieldName];
        }

        return $params;
    }

    /**
     * @param \Doctrine\ORM\PersistentCollection $collection
     * @param string                             $key
     * @param boolean                            $addFilters Whether the filter SQL should be included or not.
     *
     * @return array 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
     */
    private function getJoinTableRestrictionsWithKey(PersistentCollection $collection, $key, $addFilters)
    {
        $association       = $collection->getMapping();
        $owningAssociation = $association;
        $indexBy           = $owningAssociation->getIndexedBy();
        $identifier        = $this->uow->getEntityIdentifier($collection->getOwner());
        $sourceClass       = $this->em->getClassMetadata($owningAssociation->getSourceEntity());
        $targetClass       = $this->em->getClassMetadata($owningAssociation->getTargetEntity());

        if (! $owningAssociation->isOwningSide()) {
            $owningAssociation  = $targetClass->getProperty($owningAssociation->getMappedBy());

            $joinTable          = $owningAssociation->getJoinTable();
            $joinColumns        = $joinTable->getJoinColumns();
            $inverseJoinColumns = $joinTable->getInverseJoinColumns();
        } else {
            $joinTable          = $owningAssociation->getJoinTable();
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            $joinColumns        = $joinTable->getInverseJoinColumns();
            $inverseJoinColumns = $joinTable->getJoinColumns();
        }

        $joinTableName   = $joinTable->getQuotedQualifiedName($this->platform);
        $quotedJoinTable = $joinTableName . ' t';
        $whereClauses    = [];
        $params          = [];
        $types           = [];
        $joinNeeded      = ! in_array($indexBy, $targetClass->identifier);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        if ($joinNeeded) { // extra join needed if indexBy is not a @id
            $joinConditions = [];

            foreach ($joinColumns as $joinColumn) {

                /** @var JoinColumnMetadata $joinColumn */
                $quotedColumnName           = $this->platform->quoteIdentifier($joinColumn->getColumnName());
                $quotedReferencedColumnName = $this->platform->quoteIdentifier($joinColumn->getReferencedColumnName());

                $joinConditions[] = ' t.' . $quotedColumnName . ' = ' . 'tr.' . $quotedReferencedColumnName;
            }

            $tableName        = $targetClass->table->getQuotedQualifiedName($this->platform);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $quotedJoinTable .= ' JOIN ' . $tableName . ' tr ON ' . implode(' AND ', $joinConditions);
            $indexByProperty  = $targetClass->getProperty($indexBy);


            switch (true) {
                case ($indexByProperty instanceof FieldMetadata):

                    $quotedColumnName = $this->platform->quoteIdentifier($indexByProperty->getColumnName());

                    $whereClauses[] = sprintf('tr.%s = ?', $quotedColumnName);
                    $params[]       = $key;
                    $types[]        = $indexByProperty->getType();
                    break;

                case ($indexByProperty instanceof ToOneAssociationMetadata && $indexByProperty->isOwningSide()):
                    // Cannot be supported because PHP does not accept objects as keys. =(
                    break;
            }
        }

        foreach ($inverseJoinColumns as $joinColumn) {

            /** @var JoinColumnMetadata $joinColumn */
            $quotedColumnName     = $this->platform->quoteIdentifier($joinColumn->getColumnName());
            $referencedColumnName = $joinColumn->getReferencedColumnName();

            if (! $joinColumn->getType()) {
                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $sourceClass, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $whereClauses[] = sprintf('t.%s = ?', $quotedColumnName);
            $params[]       = $identifier[$sourceClass->fieldNames[$joinColumn->getReferencedColumnName()]];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $types[]        = $joinColumn->getType();
        }

        if (! $joinNeeded) {
            foreach ($joinColumns as $joinColumn) {

                /** @var JoinColumnMetadata $joinColumn */
                $quotedColumnName     = $this->platform->quoteIdentifier($joinColumn->getColumnName());
                $referencedColumnName = $joinColumn->getReferencedColumnName();

                if (! $joinColumn->getType()) {
                    $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $targetClass, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                }

                $whereClauses[] = sprintf('t.%s = ?', $quotedColumnName);
                $params[]       = $key;
                $types[]        = $joinColumn->getType();
            }
        }

        if ($addFilters) {

            list($joinTargetEntitySQL, $filterSql) = $this->getFilterSql($association);


            if ($filterSql) {
                $quotedJoinTable .= ' ' . $joinTargetEntitySQL;
                $whereClauses[] = $filterSql;
            }
        }

        return [$quotedJoinTable, $whereClauses, $params, $types];
    }

    /**
     * @param \Doctrine\ORM\PersistentCollection $collection
     * @param object                             $element
     * @param boolean                            $addFilters Whether the filter SQL should be included or not.
     *
     * @return array 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
     */
    private function getJoinTableRestrictions(PersistentCollection $collection, $element, $addFilters)
    {
        $association       = $collection->getMapping();
        $owningAssociation = $association;

        if (! $association->isOwningSide()) {
            $sourceClass      = $this->em->getClassMetadata($association->getTargetEntity());
            $targetClass      = $this->em->getClassMetadata($association->getSourceEntity());
            $sourceIdentifier = $this->uow->getEntityIdentifier($element);
            $targetIdentifier = $this->uow->getEntityIdentifier($collection->getOwner());

            $owningAssociation = $sourceClass->getProperty($association->getMappedBy());

        } else {
            $sourceClass      = $this->em->getClassMetadata($association->getSourceEntity());
            $targetClass      = $this->em->getClassMetadata($association->getTargetEntity());
            $sourceIdentifier = $this->uow->getEntityIdentifier($collection->getOwner());
            $targetIdentifier = $this->uow->getEntityIdentifier($element);
        }

        $joinTable       = $owningAssociation->getJoinTable();
        $joinTableName   = $joinTable->getQuotedQualifiedName($this->platform);
        $quotedJoinTable = $joinTableName;
        $whereClauses    = [];
        $params          = [];
        $types           = [];

        foreach ($joinTable->getJoinColumns() as $joinColumn) {

            /** @var JoinColumnMetadata $joinColumn */
            $quotedColumnName     = $this->platform->quoteIdentifier($joinColumn->getColumnName());
            $referencedColumnName = $joinColumn->getReferencedColumnName();

            if (! $joinColumn->getType()) {
                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $sourceClass, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $whereClauses[] = ($addFilters ? 't.' : '') . $quotedColumnName . ' = ?';
            $params[]       = $sourceIdentifier[$sourceClass->fieldNames[$referencedColumnName]];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $types[]        = $joinColumn->getType();
        }

        foreach ($joinTable->getInverseJoinColumns() as $joinColumn) {

            /** @var JoinColumnMetadata $joinColumn */
            $quotedColumnName     = $this->platform->quoteIdentifier($joinColumn->getColumnName());
            $referencedColumnName = $joinColumn->getReferencedColumnName();

            if (! $joinColumn->getType()) {
                $joinColumn->setType(PersisterHelper::getTypeOfColumn($referencedColumnName, $targetClass, $this->em));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }

            $whereClauses[] = ($addFilters ? 't.' : '') . $quotedColumnName . ' = ?';
            $params[]       = $targetIdentifier[$targetClass->fieldNames[$referencedColumnName]];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $types[]        = $joinColumn->getType();
        }

        if ($addFilters) {

            $quotedJoinTable .= ' t';

            list($joinTargetEntitySQL, $filterSql) = $this->getFilterSql($association);


            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.
     *
     * @param \Doctrine\Common\Collections\Criteria $criteria
     *
     * @return array
     */
    private function expandCriteriaParameters(Criteria $criteria)
    {
        $expression = $criteria->getWhereExpression();

        if ($expression === null) {
            return [];
        }

        $valueVisitor = new SqlValueVisitor();

        $valueVisitor->dispatch($expression);

        list(, $types) = $valueVisitor->getParamsAndTypes();

        return $types;
    }

    /**
     * @param Criteria $criteria
     * @param ClassMetadata $targetClass
     * @return string
     */
    private function getOrderingSql(Criteria $criteria, ClassMetadata $targetClass)
    {
        $orderings = $criteria->getOrderings();

        if ($orderings) {

            $orderBy = [];

            foreach ($orderings as $name => $direction) {
                $property   = $targetClass->getProperty($name);
                $columnName = $this->platform->quoteIdentifier($property->getColumnName());

                $orderBy[] = $columnName . ' ' . $direction;
            }

            return ' ORDER BY ' . implode(', ', $orderBy);
        }
        return '';
    }

    /**
     * @param Criteria $criteria
     * @return string
     * @throws \Doctrine\DBAL\DBALException
     */
    private function getLimitSql(Criteria $criteria)
    {
        $limit  = $criteria->getMaxResults();
        $offset = $criteria->getFirstResult();
        if ($limit !== null || $offset !== null) {

            return $this->platform->modifyLimitQuery('', $limit, $offset);
        }
        return '';
    }
}

Push — develop ( 082d66...6f26e1 )

ManyToManyPersister::getDeleteRowSQLParameters() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\ORM\Persisters\Collection;
6
7			use Doctrine\Common\Collections\Criteria;
8			use Doctrine\ORM\Mapping\AssociationMetadata;
9			use Doctrine\ORM\Mapping\ClassMetadata;
10			use Doctrine\ORM\Mapping\FieldMetadata;
11			use Doctrine\ORM\Mapping\JoinColumnMetadata;
12			use Doctrine\ORM\Mapping\ManyToManyAssociationMetadata;
13			use Doctrine\ORM\Mapping\ToManyAssociationMetadata;
14			use Doctrine\ORM\Mapping\ToOneAssociationMetadata;
15			use Doctrine\ORM\Persisters\SqlValueVisitor;
16			use Doctrine\ORM\PersistentCollection;
17			use Doctrine\ORM\Query;
18			use Doctrine\ORM\Utility\PersisterHelper;
19
20			/**
21			* Persister for many-to-many collections.
22			*
23			* @author Roman Borschel <[email protected]>
24			* @author Guilherme Blanco <[email protected]>
25			* @author Alexander <[email protected]>
26			* @since 2.0
27			*/
28			class ManyToManyPersister extends AbstractCollectionPersister
29			{
30			/**
31			* {@inheritdoc}
32			*/
33			public function delete(PersistentCollection $collection)
34			{
35			$association = $collection->getMapping();
36
37			if (! $association->isOwningSide()) {
38			return; // ignore inverse side
39			}
40
doctrine / orm

Push — develop ( 082d66...6f26e1 )

ManyToManyPersister::getDeleteRowSQLParameters() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
