vendor/doctrine/orm/lib/Doctrine/ORM/Persisters/Collection/ManyToManyPersister.php line 285

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ORM\Persisters\Collection;
  22. use Doctrine\Common\Collections\Criteria;
  23. use Doctrine\ORM\Mapping\ClassMetadata;
  24. use Doctrine\ORM\Persisters\SqlValueVisitor;
  25. use Doctrine\ORM\PersistentCollection;
  26. use Doctrine\ORM\Query;
  27. use Doctrine\ORM\Utility\PersisterHelper;
  29. /**
  30.  * Persister for many-to-many collections.
  31.  *
  32.  * @author  Roman Borschel <roman@code-factory.org>
  33.  * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
  34.  * @author  Alexander <iam.asm89@gmail.com>
  35.  * @since   2.0
  36.  */
  37. class ManyToManyPersister extends AbstractCollectionPersister
  38. {
  39.     /**
  40.      * {@inheritdoc}
  41.      */
  42.     public function delete(PersistentCollection $collection)
  43.     {
  44.         $mapping = $collection->getMapping();
  46.         if ( ! $mapping['isOwningSide']) {
  47.             return; // ignore inverse side
  48.         }
  50.         $types = [];
  51.         $class = $this->em->getClassMetadata($mapping['sourceEntity']);
  53.         foreach ($mapping['joinTable']['joinColumns'] as $joinColumn) {
  54.             $types[] = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $class, $this->em);
  55.         }
  57.         $this->conn->executeUpdate($this->getDeleteSQL($collection), $this->getDeleteSQLParameters($collection), $types);
  58.     }
  60.     /**
  61.      * {@inheritdoc}
  62.      */
  63.     public function update(PersistentCollection $collection)
  64.     {
  65.         $mapping = $collection->getMapping();
  67.         if ( ! $mapping['isOwningSide']) {
  68.             return; // ignore inverse side
  69.         }
  71.         list($deleteSql, $deleteTypes) = $this->getDeleteRowSQL($collection);
  72.         list($insertSql, $insertTypes) = $this->getInsertRowSQL($collection);
  74.         foreach ($collection->getDeleteDiff() as $element) {
  75.             $this->conn->executeUpdate(
  76.                 $deleteSql,
  77.                 $this->getDeleteRowSQLParameters($collection, $element),
  78.                 $deleteTypes
  79.             );
  80.         }
  82.         foreach ($collection->getInsertDiff() as $element) {
  83.             $this->conn->executeUpdate(
  84.                 $insertSql,
  85.                 $this->getInsertRowSQLParameters($collection, $element),
  86.                 $insertTypes
  87.             );
  88.         }
  89.     }
  91.     /**
  92.      * {@inheritdoc}
  93.      */
  94.     public function get(PersistentCollection $collection, $index)
  95.     {
  96.         $mapping = $collection->getMapping();
  98.         if ( ! isset($mapping['indexBy'])) {
  99.             throw new \BadMethodCallException("Selecting a collection by index is only supported on indexed collections.");
  100.         }
  102.         $persister = $this->uow->getEntityPersister($mapping['targetEntity']);
  103.         $mappedKey = $mapping['isOwningSide']
  104.             ? $mapping['inversedBy']
  105.             : $mapping['mappedBy'];
  107.         return $persister->load([$mappedKey => $collection->getOwner(), $mapping['indexBy'] => $index], null, $mapping, [], 0, 1);
  108.     }
  110.     /**
  111.      * {@inheritdoc}
  112.      */
  113.     public function count(PersistentCollection $collection)
  114.     {
  115.         $conditions     = [];
  116.         $params         = [];
  117.         $types          = [];
  118.         $mapping        = $collection->getMapping();
  119.         $id             = $this->uow->getEntityIdentifier($collection->getOwner());
  120.         $sourceClass    = $this->em->getClassMetadata($mapping['sourceEntity']);
  121.         $targetClass    = $this->em->getClassMetadata($mapping['targetEntity']);
  122.         $association    = ( ! $mapping['isOwningSide'])
  123.             ? $targetClass->associationMappings[$mapping['mappedBy']]
  124.             : $mapping;
  126.         $joinTableName  = $this->quoteStrategy->getJoinTableName($association, $sourceClass, $this->platform);
  127.         $joinColumns    = ( ! $mapping['isOwningSide'])
  128.             ? $association['joinTable']['inverseJoinColumns']
  129.             : $association['joinTable']['joinColumns'];
  131.         foreach ($joinColumns as $joinColumn) {
  132.             $columnName     = $this->quoteStrategy->getJoinColumnName($joinColumn, $sourceClass, $this->platform);
  133.             $referencedName = $joinColumn['referencedColumnName'];
  134.             $conditions[]   = 't.' . $columnName . ' = ?';
  135.             $params[]       = $id[$sourceClass->getFieldForColumn($referencedName)];
  136.             $types[]        = PersisterHelper::getTypeOfColumn($referencedName, $sourceClass, $this->em);
  137.         }
  139.         list($joinTargetEntitySQL, $filterSql) = $this->getFilterSql($mapping);
  141.         if ($filterSql) {
  142.             $conditions[] = $filterSql;
  143.         }
  145.         // If there is a provided criteria, make part of conditions
  146.         // @todo Fix this. Current SQL returns something like:
  147.         //
  148.         /*if ($criteria && ($expression = $criteria->getWhereExpression()) !== null) {
  149.             // A join is needed on the target entity
  150.             $targetTableName = $this->quoteStrategy->getTableName($targetClass, $this->platform);
  151.             $targetJoinSql   = ' JOIN ' . $targetTableName . ' te'
  152.                 . ' ON' . implode(' AND ', $this->getOnConditionSQL($association));
  154.             // And criteria conditions needs to be added
  155.             $persister    = $this->uow->getEntityPersister($targetClass->name);
  156.             $visitor      = new SqlExpressionVisitor($persister, $targetClass);
  157.             $conditions[] = $visitor->dispatch($expression);
  159.             $joinTargetEntitySQL = $targetJoinSql . $joinTargetEntitySQL;
  160.         }*/
  162.         $sql = 'SELECT COUNT(*)'
  163.             . ' FROM ' . $joinTableName . ' t'
  164.             . $joinTargetEntitySQL
  165.             . ' WHERE ' . implode(' AND ', $conditions);
  167.         return $this->conn->fetchColumn($sql, $params, 0, $types);
  168.     }
  170.     /**
  171.      * {@inheritDoc}
  172.      */
  173.     public function slice(PersistentCollection $collection, $offset, $length = null)
  174.     {
  175.         $mapping   = $collection->getMapping();
  176.         $persister = $this->uow->getEntityPersister($mapping['targetEntity']);
  178.         return $persister->getManyToManyCollection($mapping, $collection->getOwner(), $offset, $length);
  179.     }
  180.     /**
  181.      * {@inheritdoc}
  182.      */
  183.     public function containsKey(PersistentCollection $collection, $key)
  184.     {
  185.         $mapping = $collection->getMapping();
  187.         if ( ! isset($mapping['indexBy'])) {
  188.             throw new \BadMethodCallException("Selecting a collection by index is only supported on indexed collections.");
  189.         }
  191.         list($quotedJoinTable, $whereClauses, $params, $types) = $this->getJoinTableRestrictionsWithKey($collection, $key, true);
  193.         $sql = 'SELECT 1 FROM ' . $quotedJoinTable . ' WHERE ' . implode(' AND ', $whereClauses);
  195.         return (bool) $this->conn->fetchColumn($sql, $params, 0, $types);
  196.     }
  198.     /**
  199.      * {@inheritDoc}
  200.      */
  201.     public function contains(PersistentCollection $collection, $element)
  202.     {
  203.         if ( ! $this->isValidEntityState($element)) {
  204.             return false;
  205.         }
  207.         list($quotedJoinTable, $whereClauses, $params, $types) = $this->getJoinTableRestrictions($collection, $element, true);
  209.         $sql = 'SELECT 1 FROM ' . $quotedJoinTable . ' WHERE ' . implode(' AND ', $whereClauses);
  211.         return (bool) $this->conn->fetchColumn($sql, $params, 0, $types);
  212.     }
  214.     /**
  215.      * {@inheritDoc}
  216.      */
  217.     public function removeElement(PersistentCollection $collection, $element)
  218.     {
  219.         if ( ! $this->isValidEntityState($element)) {
  220.             return false;
  221.         }
  223.         list($quotedJoinTable, $whereClauses, $params, $types) = $this->getJoinTableRestrictions($collection, $element, false);
  225.         $sql = 'DELETE FROM ' . $quotedJoinTable . ' WHERE ' . implode(' AND ', $whereClauses);
  227.         return (bool) $this->conn->executeUpdate($sql, $params, $types);
  228.     }
  230.     /**
  231.      * {@inheritDoc}
  232.      */
  233.     public function loadCriteria(PersistentCollection $collection, Criteria $criteria)
  234.     {
  235.         $mapping       = $collection->getMapping();
  236.         $owner         = $collection->getOwner();
  237.         $ownerMetadata = $this->em->getClassMetadata(get_class($owner));
  238.         $id            = $this->uow->getEntityIdentifier($owner);
  239.         $targetClass   = $this->em->getClassMetadata($mapping['targetEntity']);
  240.         $onConditions  = $this->getOnConditionSQL($mapping);
  241.         $whereClauses  = $params = [];
  243.         if ( ! $mapping['isOwningSide']) {
  244.             $associationSourceClass = $targetClass;
  245.             $mapping = $targetClass->associationMappings[$mapping['mappedBy']];
  246.             $sourceRelationMode = 'relationToTargetKeyColumns';
  247.         } else {
  248.             $associationSourceClass = $ownerMetadata;
  249.             $sourceRelationMode = 'relationToSourceKeyColumns';
  250.         }
  252.         foreach ($mapping[$sourceRelationMode] as $key => $value) {
  253.             $whereClauses[] = sprintf('t.%s = ?', $key);
  254.             $params[] = $ownerMetadata->containsForeignIdentifier
  255.                 ? $id[$ownerMetadata->getFieldForColumn($value)]
  256.                 : $id[$ownerMetadata->fieldNames[$value]];
  257.         }
  259.         $parameters = $this->expandCriteriaParameters($criteria);
  261.         foreach ($parameters as $parameter) {
  262.             [$name, $value, $operator] = $parameter;
  264.             $field          = $this->quoteStrategy->getColumnName($name, $targetClass, $this->platform);
  265.             $whereClauses[] = sprintf('te.%s %s ?', $field, $operator);
  266.             $params[]       = $value;
  267.         }
  269.         $tableName    = $this->quoteStrategy->getTableName($targetClass, $this->platform);
  270.         $joinTable    = $this->quoteStrategy->getJoinTableName($mapping, $associationSourceClass, $this->platform);
  272.         $rsm = new Query\ResultSetMappingBuilder($this->em);
  273.         $rsm->addRootEntityFromClassMetadata($targetClass->name, 'te');
  275.         $sql = 'SELECT ' . $rsm->generateSelectClause()
  276.             . ' FROM ' . $tableName . ' te'
  277.             . ' JOIN ' . $joinTable  . ' t ON'
  278.             . implode(' AND ', $onConditions)
  279.             . ' WHERE ' . implode(' AND ', $whereClauses);
  281.         $sql .= $this->getOrderingSql($criteria, $targetClass);
  283.         $sql .= $this->getLimitSql($criteria);
  285.         $stmt = $this->conn->executeQuery($sql, $params);
  287.         return $this
  288.             ->em
  289.             ->newHydrator(Query::HYDRATE_OBJECT)
  290.             ->hydrateAll($stmt, $rsm);
  291.     }
  293.     /**
  294.      * Generates the filter SQL for a given mapping.
  295.      *
  296.      * This method is not used for actually grabbing the related entities
  297.      * but when the extra-lazy collection methods are called on a filtered
  298.      * association. This is why besides the many to many table we also
  299.      * have to join in the actual entities table leading to additional
  300.      * JOIN.
  301.      *
  302.      * @param array $mapping Array containing mapping information.
  303.      *
  304.      * @return string[] ordered tuple:
  305.      *                   - JOIN condition to add to the SQL
  306.      *                   - WHERE condition to add to the SQL
  307.      */
  308.     public function getFilterSql($mapping)
  309.     {
  310.         $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
  311.         $rootClass   = $this->em->getClassMetadata($targetClass->rootEntityName);
  312.         $filterSql   = $this->generateFilterConditionSQL($rootClass, 'te');
  314.         if ('' === $filterSql) {
  315.             return ['', ''];
  316.         }
  318.         // A join is needed if there is filtering on the target entity
  319.         $tableName = $this->quoteStrategy->getTableName($rootClass, $this->platform);
  320.         $joinSql   = ' JOIN ' . $tableName . ' te'
  321.             . ' ON' . implode(' AND ', $this->getOnConditionSQL($mapping));
  323.         return [$joinSql, $filterSql];
  324.     }
  326.     /**
  327.      * Generates the filter SQL for a given entity and table alias.
  328.      *
  329.      * @param ClassMetadata $targetEntity     Metadata of the target entity.
  330.      * @param string        $targetTableAlias The table alias of the joined/selected table.
  331.      *
  332.      * @return string The SQL query part to add to a query.
  333.      */
  334.     protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias)
  335.     {
  336.         $filterClauses = [];
  338.         foreach ($this->em->getFilters()->getEnabledFilters() as $filter) {
  339.             if ($filterExpr = $filter->addFilterConstraint($targetEntity, $targetTableAlias)) {
  340.                 $filterClauses[] = '(' . $filterExpr . ')';
  341.             }
  342.         }
  344.         return $filterClauses
  345.             ? '(' . implode(' AND ', $filterClauses) . ')'
  346.             : '';
  347.     }
  349.     /**
  350.      * Generate ON condition
  351.      *
  352.      * @param  array $mapping
  353.      *
  354.      * @return array
  355.      */
  356.     protected function getOnConditionSQL($mapping)
  357.     {
  358.         $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
  359.         $association = ( ! $mapping['isOwningSide'])
  360.             ? $targetClass->associationMappings[$mapping['mappedBy']]
  361.             : $mapping;
  363.         $joinColumns = $mapping['isOwningSide']
  364.             ? $association['joinTable']['inverseJoinColumns']
  365.             : $association['joinTable']['joinColumns'];
  367.         $conditions = [];
  369.         foreach ($joinColumns as $joinColumn) {
  370.             $joinColumnName = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  371.             $refColumnName  = $this->quoteStrategy->getReferencedJoinColumnName($joinColumn, $targetClass, $this->platform);
  373.             $conditions[] = ' t.' . $joinColumnName . ' = ' . 'te.' . $refColumnName;
  374.         }
  376.         return $conditions;
  377.     }
  379.     /**
  380.      * {@inheritdoc}
  381.      *
  382.      * @override
  383.      */
  384.     protected function getDeleteSQL(PersistentCollection $collection)
  385.     {
  386.         $columns    = [];
  387.         $mapping    = $collection->getMapping();
  388.         $class      = $this->em->getClassMetadata(get_class($collection->getOwner()));
  389.         $joinTable  = $this->quoteStrategy->getJoinTableName($mapping, $class, $this->platform);
  391.         foreach ($mapping['joinTable']['joinColumns'] as $joinColumn) {
  392.             $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  393.         }
  395.         return 'DELETE FROM ' . $joinTable
  396.             . ' WHERE ' . implode(' = ? AND ', $columns) . ' = ?';
  397.     }
  399.     /**
  400.      * {@inheritdoc}
  401.      *
  402.      * Internal note: Order of the parameters must be the same as the order of the columns in getDeleteSql.
  403.      * @override
  404.      */
  405.     protected function getDeleteSQLParameters(PersistentCollection $collection)
  406.     {
  407.         $mapping    = $collection->getMapping();
  408.         $identifier = $this->uow->getEntityIdentifier($collection->getOwner());
  410.         // Optimization for single column identifier
  411.         if (count($mapping['relationToSourceKeyColumns']) === 1) {
  412.             return [reset($identifier)];
  413.         }
  415.         // Composite identifier
  416.         $sourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
  417.         $params      = [];
  419.         foreach ($mapping['relationToSourceKeyColumns'] as $columnName => $refColumnName) {
  420.             $params[] = isset($sourceClass->fieldNames[$refColumnName])
  421.                 ? $identifier[$sourceClass->fieldNames[$refColumnName]]
  422.                 : $identifier[$sourceClass->getFieldForColumn($refColumnName)];
  423.         }
  425.         return $params;
  426.     }
  428.     /**
  429.      * Gets the SQL statement used for deleting a row from the collection.
  430.      *
  431.      * @param \Doctrine\ORM\PersistentCollection $collection
  432.      *
  433.      * @return string[]|string[][] ordered tuple containing the SQL to be executed and an array
  434.      *                             of types for bound parameters
  435.      */
  436.     protected function getDeleteRowSQL(PersistentCollection $collection)
  437.     {
  438.         $mapping     = $collection->getMapping();
  439.         $class       = $this->em->getClassMetadata($mapping['sourceEntity']);
  440.         $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
  441.         $columns     = [];
  442.         $types       = [];
  444.         foreach ($mapping['joinTable']['joinColumns'] as $joinColumn) {
  445.             $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $class, $this->platform);
  446.             $types[]   = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $class, $this->em);
  447.         }
  449.         foreach ($mapping['joinTable']['inverseJoinColumns'] as $joinColumn) {
  450.             $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  451.             $types[]   = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  452.         }
  454.         return [
  455.             'DELETE FROM ' . $this->quoteStrategy->getJoinTableName($mapping, $class, $this->platform)
  456.             . ' WHERE ' . implode(' = ? AND ', $columns) . ' = ?',
  457.             $types,
  458.         ];
  459.     }
  461.     /**
  462.      * Gets the SQL parameters for the corresponding SQL statement to delete the given
  463.      * element from the given collection.
  464.      *
  465.      * Internal note: Order of the parameters must be the same as the order of the columns in getDeleteRowSql.
  466.      *
  467.      * @param \Doctrine\ORM\PersistentCollection $collection
  468.      * @param mixed                              $element
  469.      *
  470.      * @return array
  471.      */
  472.     protected function getDeleteRowSQLParameters(PersistentCollection $collection, $element)
  473.     {
  474.         return $this->collectJoinTableColumnParameters($collection, $element);
  475.     }
  477.     /**
  478.      * Gets the SQL statement used for inserting a row in the collection.
  479.      *
  480.      * @param \Doctrine\ORM\PersistentCollection $collection
  481.      *
  482.      * @return string[]|string[][] ordered tuple containing the SQL to be executed and an array
  483.      *                             of types for bound parameters
  484.      */
  485.     protected function getInsertRowSQL(PersistentCollection $collection)
  486.     {
  487.         $columns     = [];
  488.         $types       = [];
  489.         $mapping     = $collection->getMapping();
  490.         $class       = $this->em->getClassMetadata($mapping['sourceEntity']);
  491.         $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
  493.         foreach ($mapping['joinTable']['joinColumns'] as $joinColumn) {
  494.             $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  495.             $types[]   = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $class, $this->em);
  496.         }
  498.         foreach ($mapping['joinTable']['inverseJoinColumns'] as $joinColumn) {
  499.             $columns[] = $this->quoteStrategy->getJoinColumnName($joinColumn, $targetClass, $this->platform);
  500.             $types[]   = PersisterHelper::getTypeOfColumn($joinColumn['referencedColumnName'], $targetClass, $this->em);
  501.         }
  503.         return [
  504.             'INSERT INTO ' . $this->quoteStrategy->getJoinTableName($mapping, $class, $this->platform)
  505.             . ' (' . implode(', ', $columns) . ')'
  506.             . ' VALUES'
  507.             . ' (' . implode(', ', array_fill(0, count($columns), '?')) . ')',
  508.             $types,
  509.         ];
  510.     }
  512.     /**
  513.      * Gets the SQL parameters for the corresponding SQL statement to insert the given
  514.      * element of the given collection into the database.
  515.      *
  516.      * Internal note: Order of the parameters must be the same as the order of the columns in getInsertRowSql.
  517.      *
  518.      * @param \Doctrine\ORM\PersistentCollection $collection
  519.      * @param mixed                              $element
  520.      *
  521.      * @return array
  522.      */
  523.     protected function getInsertRowSQLParameters(PersistentCollection $collection, $element)
  524.     {
  525.         return $this->collectJoinTableColumnParameters($collection, $element);
  526.     }
  528.     /**
  529.      * Collects the parameters for inserting/deleting on the join table in the order
  530.      * of the join table columns as specified in ManyToManyMapping#joinTableColumns.
  531.      *
  532.      * @param \Doctrine\ORM\PersistentCollection $collection
  533.      * @param object                             $element
  534.      *
  535.      * @return array
  536.      */
  537.     private function collectJoinTableColumnParameters(PersistentCollection $collection, $element)
  538.     {
  539.         $params      = [];
  540.         $mapping     = $collection->getMapping();
  541.         $isComposite = count($mapping['joinTableColumns']) > 2;
  543.         $identifier1 = $this->uow->getEntityIdentifier($collection->getOwner());
  544.         $identifier2 = $this->uow->getEntityIdentifier($element);
  546.         $class1 = $class2 = null;
  547.         if ($isComposite) {
  548.             $class1 = $this->em->getClassMetadata(get_class($collection->getOwner()));
  549.             $class2 = $collection->getTypeClass();
  550.         }
  552.         foreach ($mapping['joinTableColumns'] as $joinTableColumn) {
  553.             $isRelationToSource = isset($mapping['relationToSourceKeyColumns'][$joinTableColumn]);
  555.             if ( ! $isComposite) {
  556.                 $params[] = $isRelationToSource ? array_pop($identifier1) : array_pop($identifier2);
  558.                 continue;
  559.             }
  561.             if ($isRelationToSource) {
  562.                 $params[] = $identifier1[$class1->getFieldForColumn($mapping['relationToSourceKeyColumns'][$joinTableColumn])];
  564.                 continue;
  565.             }
  567.             $params[] = $identifier2[$class2->getFieldForColumn($mapping['relationToTargetKeyColumns'][$joinTableColumn])];
  568.         }
  570.         return $params;
  571.     }
  573.     /**
  574.      * @param \Doctrine\ORM\PersistentCollection $collection
  575.      * @param string                             $key
  576.      * @param boolean                            $addFilters Whether the filter SQL should be included or not.
  577.      *
  578.      * @return array ordered vector:
  579.      *                - quoted join table name
  580.      *                - where clauses to be added for filtering
  581.      *                - parameters to be bound for filtering
  582.      *                - types of the parameters to be bound for filtering
  583.      */
  584.     private function getJoinTableRestrictionsWithKey(PersistentCollection $collection, $key, $addFilters)
  585.     {
  586.         $filterMapping = $collection->getMapping();
  587.         $mapping       = $filterMapping;
  588.         $indexBy       = $mapping['indexBy'];
  589.         $id            = $this->uow->getEntityIdentifier($collection->getOwner());
  590.         $sourceClass   = $this->em->getClassMetadata($mapping['sourceEntity']);
  591.         $targetClass   = $this->em->getClassMetadata($mapping['targetEntity']);
  593.         if (! $mapping['isOwningSide']) {
  594.             $associationSourceClass = $this->em->getClassMetadata($mapping['targetEntity']);
  595.             $mapping                = $associationSourceClass->associationMappings[$mapping['mappedBy']];
  596.             $joinColumns            = $mapping['joinTable']['joinColumns'];
  597.             $sourceRelationMode     = 'relationToTargetKeyColumns';
  598.             $targetRelationMode     = 'relationToSourceKeyColumns';
  599.         } else {
  600.             $associationSourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
  601.             $joinColumns            = $mapping['joinTable']['inverseJoinColumns'];
  602.             $sourceRelationMode     = 'relationToSourceKeyColumns';
  603.             $targetRelationMode     = 'relationToTargetKeyColumns';
  604.         }
  606.         $quotedJoinTable = $this->quoteStrategy->getJoinTableName($mapping, $associationSourceClass, $this->platform). ' t';
  607.         $whereClauses    = [];
  608.         $params          = [];
  609.         $types           = [];
  611.         $joinNeeded = ! in_array($indexBy, $targetClass->identifier);
  613.         if ($joinNeeded) { // extra join needed if indexBy is not a @id
  614.             $joinConditions = [];
  616.             foreach ($joinColumns as $joinTableColumn) {
  617.                 $joinConditions[] = 't.' . $joinTableColumn['name'] . ' = tr.' . $joinTableColumn['referencedColumnName'];
  618.             }
  620.             $tableName        = $this->quoteStrategy->getTableName($targetClass, $this->platform);
  621.             $quotedJoinTable .= ' JOIN ' . $tableName . ' tr ON ' . implode(' AND ', $joinConditions);
  622.             $columnName       = $targetClass->getColumnName($indexBy);
  624.             $whereClauses[] = 'tr.' . $columnName . ' = ?';
  625.             $params[]       = $key;
  626.             $types[]        = PersisterHelper::getTypeOfColumn($columnName, $targetClass, $this->em);
  627.         }
  629.         foreach ($mapping['joinTableColumns'] as $joinTableColumn) {
  630.             if (isset($mapping[$sourceRelationMode][$joinTableColumn])) {
  631.                 $column         = $mapping[$sourceRelationMode][$joinTableColumn];
  632.                 $whereClauses[] = 't.' . $joinTableColumn . ' = ?';
  633.                 $params[]       = $sourceClass->containsForeignIdentifier
  634.                     ? $id[$sourceClass->getFieldForColumn($column)]
  635.                     : $id[$sourceClass->fieldNames[$column]];
  636.                 $types[]        = PersisterHelper::getTypeOfColumn($column, $sourceClass, $this->em);
  637.             } elseif ( ! $joinNeeded) {
  638.                 $column = $mapping[$targetRelationMode][$joinTableColumn];
  640.                 $whereClauses[] = 't.' . $joinTableColumn . ' = ?';
  641.                 $params[]       = $key;
  642.                 $types[]        = PersisterHelper::getTypeOfColumn($column, $targetClass, $this->em);
  643.             }
  644.         }
  646.         if ($addFilters) {
  647.             list($joinTargetEntitySQL, $filterSql) = $this->getFilterSql($filterMapping);
  649.             if ($filterSql) {
  650.                 $quotedJoinTable .= ' ' . $joinTargetEntitySQL;
  651.                 $whereClauses[] = $filterSql;
  652.             }
  653.         }
  655.         return [$quotedJoinTable, $whereClauses, $params, $types];
  656.     }
  658.     /**
  659.      * @param \Doctrine\ORM\PersistentCollection $collection
  660.      * @param object                             $element
  661.      * @param boolean                            $addFilters Whether the filter SQL should be included or not.
  662.      *
  663.      * @return array ordered vector:
  664.      *                - quoted join table name
  665.      *                - where clauses to be added for filtering
  666.      *                - parameters to be bound for filtering
  667.      *                - types of the parameters to be bound for filtering
  668.      */
  669.     private function getJoinTableRestrictions(PersistentCollection $collection, $element, $addFilters)
  670.     {
  671.         $filterMapping  = $collection->getMapping();
  672.         $mapping        = $filterMapping;
  674.         if ( ! $mapping['isOwningSide']) {
  675.             $sourceClass = $this->em->getClassMetadata($mapping['targetEntity']);
  676.             $targetClass = $this->em->getClassMetadata($mapping['sourceEntity']);
  677.             $sourceId = $this->uow->getEntityIdentifier($element);
  678.             $targetId = $this->uow->getEntityIdentifier($collection->getOwner());
  680.             $mapping = $sourceClass->associationMappings[$mapping['mappedBy']];
  681.         } else {
  682.             $sourceClass = $this->em->getClassMetadata($mapping['sourceEntity']);
  683.             $targetClass = $this->em->getClassMetadata($mapping['targetEntity']);
  684.             $sourceId = $this->uow->getEntityIdentifier($collection->getOwner());
  685.             $targetId = $this->uow->getEntityIdentifier($element);
  686.         }
  688.         $quotedJoinTable = $this->quoteStrategy->getJoinTableName($mapping, $sourceClass, $this->platform);
  689.         $whereClauses    = [];
  690.         $params          = [];
  691.         $types           = [];
  693.         foreach ($mapping['joinTableColumns'] as $joinTableColumn) {
  694.             $whereClauses[] = ($addFilters ? 't.' : '') . $joinTableColumn . ' = ?';
  696.             if (isset($mapping['relationToTargetKeyColumns'][$joinTableColumn])) {
  697.                 $targetColumn = $mapping['relationToTargetKeyColumns'][$joinTableColumn];
  698.                 $params[]     = $targetId[$targetClass->getFieldForColumn($targetColumn)];
  699.                 $types[]      = PersisterHelper::getTypeOfColumn($targetColumn, $targetClass, $this->em);
  701.                 continue;
  702.             }
  704.             // relationToSourceKeyColumns
  705.             $targetColumn = $mapping['relationToSourceKeyColumns'][$joinTableColumn];
  706.             $params[]     = $sourceId[$sourceClass->getFieldForColumn($targetColumn)];
  707.             $types[]      = PersisterHelper::getTypeOfColumn($targetColumn, $sourceClass, $this->em);
  708.         }
  710.         if ($addFilters) {
  711.             $quotedJoinTable .= ' t';
  713.             list($joinTargetEntitySQL, $filterSql) = $this->getFilterSql($filterMapping);
  715.             if ($filterSql) {
  716.                 $quotedJoinTable .= ' ' . $joinTargetEntitySQL;
  717.                 $whereClauses[] = $filterSql;
  718.             }
  719.         }
  721.         return [$quotedJoinTable, $whereClauses, $params, $types];
  722.     }
  724.     /**
  725.      * Expands Criteria Parameters by walking the expressions and grabbing all
  726.      * parameters and types from it.
  727.      *
  728.      * @param \Doctrine\Common\Collections\Criteria $criteria
  729.      *
  730.      * @return array
  731.      */
  732.     private function expandCriteriaParameters(Criteria $criteria)
  733.     {
  734.         $expression = $criteria->getWhereExpression();
  736.         if ($expression === null) {
  737.             return [];
  738.         }
  740.         $valueVisitor = new SqlValueVisitor();
  742.         $valueVisitor->dispatch($expression);
  744.         list(, $types) = $valueVisitor->getParamsAndTypes();
  746.         return $types;
  747.     }
  749.     /**
  750.      * @param Criteria $criteria
  751.      * @param ClassMetadata $targetClass
  752.      * @return string
  753.      */
  754.     private function getOrderingSql(Criteria $criteria, ClassMetadata $targetClass)
  755.     {
  756.         $orderings = $criteria->getOrderings();
  757.         if ($orderings) {
  758.             $orderBy = [];
  759.             foreach ($orderings as $name => $direction) {
  760.                 $field = $this->quoteStrategy->getColumnName(
  761.                     $name,
  762.                     $targetClass,
  763.                     $this->platform
  764.                 );
  765.                 $orderBy[] = $field . ' ' . $direction;
  766.             }
  768.             return ' ORDER BY ' . implode(', ', $orderBy);
  769.         }
  770.         return '';
  771.     }
  773.     /**
  774.      * @param Criteria $criteria
  775.      * @return string
  776.      * @throws \Doctrine\DBAL\DBALException
  777.      */
  778.     private function getLimitSql(Criteria $criteria)
  779.     {
  780.         $limit  = $criteria->getMaxResults();
  781.         $offset = $criteria->getFirstResult();
  782.         if ($limit !== null || $offset !== null) {
  783.             return $this->platform->modifyLimitQuery('', $limit, $offset);
  784.         }
  785.         return '';
  786.     }
  787. }