CollectionPersister::__construct() - Code Metrics - Inspection of "[WIP] Add upgrade document for ODM 1.2" - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1660)

by Andreas

created 2017-10-20 06:12 UTC

CollectionPersister::__construct() A

↳ Parent: CollectionPersister

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	5
cts	5
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	4
nc	1
nop	3
crap	1

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\ODM\MongoDB\Persisters;

use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\LockException;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo;
use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionInterface;
use Doctrine\ODM\MongoDB\UnitOfWork;
use Doctrine\ODM\MongoDB\Utility\CollectionHelper;

/**
 * The CollectionPersister is responsible for persisting collections of embedded
 * or referenced documents. When a PersistentCollection is scheduledForDeletion
 * in the UnitOfWork by calling PersistentCollection::clear() or is
 * de-referenced in the domain application code, CollectionPersister::delete()
 * will be called. When documents within the PersistentCollection are added or
 * removed, CollectionPersister::update() will be called, which may set the
 * entire collection or delete/insert individual elements, depending on the
 * mapping strategy.
 *
 * @since       1.0
 */
class CollectionPersister
{
    /**
     * The DocumentManager instance.
     *
     * @var DocumentManager
     */
    private $dm;

    /**
     * The PersistenceBuilder instance.
     *
     * @var PersistenceBuilder
     */
    private $pb;

    /**
     * Constructs a new CollectionPersister instance.
     *
     * @param DocumentManager $dm
     * @param PersistenceBuilder $pb
     * @param UnitOfWork $uow
     */
    public function __construct(DocumentManager $dm, PersistenceBuilder $pb, UnitOfWork $uow)
    {
        $this->dm = $dm;
        $this->pb = $pb;
        $this->uow = $uow;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Deletes a PersistentCollection instance completely from a document using $unset.
     *
     * @param PersistentCollectionInterface $coll
     * @param array $options
     */
    public function delete(PersistentCollectionInterface $coll, array $options)
    {
        $mapping = $coll->getMapping();
        if ($mapping['isInverseSide']) {
            return; // ignore inverse side
        }
        if (CollectionHelper::isAtomic($mapping['strategy'])) {
            throw new \UnexpectedValueException($mapping['strategy'] . ' delete collection strategy should have been handled by DocumentPersister. Please report a bug in issue tracker');
        }
        list($propertyPath, $parent) = $this->getPathAndParent($coll);
        $query = array('$unset' => array($propertyPath => true));
        $this->executeQuery($parent, $query, $options);
    }

    /**
     * Updates a PersistentCollection instance deleting removed rows and
     * inserting new rows.
     *
     * @param PersistentCollectionInterface $coll
     * @param array $options
     */
    public function update(PersistentCollectionInterface $coll, array $options)
    {
        $mapping = $coll->getMapping();

        if ($mapping['isInverseSide']) {
            return; // ignore inverse side
        }

        switch ($mapping['strategy']) {
            case ClassMetadataInfo::STORAGE_STRATEGY_ATOMIC_SET:
            case ClassMetadataInfo::STORAGE_STRATEGY_ATOMIC_SET_ARRAY:
                throw new \UnexpectedValueException($mapping['strategy'] . ' update collection strategy should have been handled by DocumentPersister. Please report a bug in issue tracker');

            case ClassMetadataInfo::STORAGE_STRATEGY_SET:
            case ClassMetadataInfo::STORAGE_STRATEGY_SET_ARRAY:
                $this->setCollection($coll, $options);
                break;

            case ClassMetadataInfo::STORAGE_STRATEGY_ADD_TO_SET:
            case ClassMetadataInfo::STORAGE_STRATEGY_PUSH_ALL:
                $coll->initialize();
                $this->deleteElements($coll, $options);
                $this->insertElements($coll, $options);
                break;

            default:
                throw new \UnexpectedValueException('Unsupported collection strategy: ' . $mapping['strategy']);
        }
    }

    /**
     * Sets a PersistentCollection instance.
     *
     * This method is intended to be used with the "set" or "setArray"
     * strategies. The "setArray" strategy will ensure that the collection is
     * set as a BSON array, which means the collection elements will be
     * reindexed numerically before storage.
     *
     * @param PersistentCollectionInterface $coll
     * @param array $options
     */
    private function setCollection(PersistentCollectionInterface $coll, array $options)
    {
        list($propertyPath, $parent) = $this->getPathAndParent($coll);
        $coll->initialize();
        $mapping = $coll->getMapping();
        $setData = $this->pb->prepareAssociatedCollectionValue($coll, CollectionHelper::usesSet($mapping['strategy']));
        $query = array('$set' => array($propertyPath => $setData));
        $this->executeQuery($parent, $query, $options);
    }

    /**
     * Deletes removed elements from a PersistentCollection instance.
     *
     * This method is intended to be used with the "pushAll" and "addToSet"
     * strategies.
     *
     * @param PersistentCollectionInterface $coll
     * @param array $options
     */
    private function deleteElements(PersistentCollectionInterface $coll, array $options)
    {
        $deleteDiff = $coll->getDeleteDiff();

        if (empty($deleteDiff)) {
            return;
        }

        list($propertyPath, $parent) = $this->getPathAndParent($coll);

        $query = array('$unset' => array());

        foreach ($deleteDiff as $key => $document) {
            $query['$unset'][$propertyPath . '.' . $key] = true;
        }

        $this->executeQuery($parent, $query, $options);

        /**
         * @todo This is a hack right now because we don't have a proper way to
         * remove an element from an array by its key. Unsetting the key results
         * in the element being left in the array as null so we have to pull
         * null values.
         */
        $this->executeQuery($parent, array('$pull' => array($propertyPath => null)), $options);
    }

    /**
     * Inserts new elements for a PersistentCollection instance.
     *
     * This method is intended to be used with the "pushAll" and "addToSet"
     * strategies.
     *
     * @param PersistentCollectionInterface $coll
     * @param array $options
     */
    private function insertElements(PersistentCollectionInterface $coll, array $options)
    {
        $insertDiff = $coll->getInsertDiff();

        if (empty($insertDiff)) {
            return;
        }

        $mapping = $coll->getMapping();
        list($propertyPath, $parent) = $this->getPathAndParent($coll);

        $pb = $this->pb;

        $callback = isset($mapping['embedded'])
            ? function($v) use ($pb, $mapping) { return $pb->prepareEmbeddedDocumentValue($mapping, $v); }
            : function($v) use ($pb, $mapping) { return $pb->prepareReferencedDocumentValue($mapping, $v); };

        $value = array_values(array_map($callback, $insertDiff));

        if ($mapping['strategy'] === ClassMetadataInfo::STORAGE_STRATEGY_ADD_TO_SET) {
            $value = array('$each' => $value);
        }

        $query = array('$' . $mapping['strategy'] => array($propertyPath => $value));

        $this->executeQuery($parent, $query, $options);
    }

    /**
     * Gets the parent information for a given PersistentCollection. It will
     * retrieve the top-level persistent Document that the PersistentCollection
     * lives in. We can use this to issue queries when updating a
     * PersistentCollection that is multiple levels deep inside an embedded
     * document.
     *
     *     <code>
     *     list($path, $parent) = $this->getPathAndParent($coll)
     *     </code>
     *
     * @param PersistentCollectionInterface $coll
     * @return array $pathAndParent
     */
    private function getPathAndParent(PersistentCollectionInterface $coll)
    {
        $mapping = $coll->getMapping();
        $fields = array();
        $parent = $coll->getOwner();
        while (null !== ($association = $this->uow->getParentAssociation($parent))) {
            list($m, $owner, $field) = $association;
            if (isset($m['reference'])) {
                break;
            }
            $parent = $owner;
            $fields[] = $field;
        }
        $propertyPath = implode('.', array_reverse($fields));
        $path = $mapping['name'];
        if ($propertyPath) {
            $path = $propertyPath . '.' . $path;
        }
        return array($path, $parent);
    }

    /**
     * Executes a query updating the given document.
     *
     * @param object $document
     * @param array $newObj
     * @param array $options
     */
    private function executeQuery($document, array $newObj, array $options)
    {
        $className = get_class($document);
        $class = $this->dm->getClassMetadata($className);
        $id = $class->getDatabaseIdentifierValue($this->uow->getDocumentIdentifier($document));
        $query = array('_id' => $id);
        if ($class->isVersioned) {
            $query[$class->fieldMappings[$class->versionField]['name']] = $class->reflFields[$class->versionField]->getValue($document);
        }
        $collection = $this->dm->getDocumentCollection($className);
        $result = $collection->update($query, $newObj, $options);
        if ($class->isVersioned && ! $result['n']) {
            throw LockException::lockFailed($document);
        }
    }
}


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		*/
19
20		namespace Doctrine\ODM\MongoDB\Persisters;
21
22		use Doctrine\ODM\MongoDB\DocumentManager;
23		use Doctrine\ODM\MongoDB\LockException;
24		use Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo;
25		use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionInterface;
26		use Doctrine\ODM\MongoDB\UnitOfWork;
27		use Doctrine\ODM\MongoDB\Utility\CollectionHelper;
28
29		/**
30		* The CollectionPersister is responsible for persisting collections of embedded
31		* or referenced documents. When a PersistentCollection is scheduledForDeletion
32		* in the UnitOfWork by calling PersistentCollection::clear() or is
33		* de-referenced in the domain application code, CollectionPersister::delete()
34		* will be called. When documents within the PersistentCollection are added or
35		* removed, CollectionPersister::update() will be called, which may set the
36		* entire collection or delete/insert individual elements, depending on the
37		* mapping strategy.
38		*
39		* @since 1.0
40		*/
41		class CollectionPersister
42		{
43		/**
44		* The DocumentManager instance.
45		*
46		* @var DocumentManager
47		*/
48		private $dm;
49
50		/**
51		* The PersistenceBuilder instance.
52		*
53		* @var PersistenceBuilder
54		*/
55		private $pb;
56
57		/**
58		* Constructs a new CollectionPersister instance.
59		*
60		* @param DocumentManager $dm
61		* @param PersistenceBuilder $pb
62		* @param UnitOfWork $uow
63		*/
64	779	public function __construct(DocumentManager $dm, PersistenceBuilder $pb, UnitOfWork $uow)
65		{
66	779	$this->dm = $dm;
67	779	$this->pb = $pb;
68	779	$this->uow = $uow;
		0 ignored issues – show Bug introduced 2015-11-24 10:15 UTC by Report Bug Copy Issue Report The property `uow` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
69	779	}
70
71		/**
72		* Deletes a PersistentCollection instance completely from a document using $unset.
73		*
74		* @param PersistentCollectionInterface $coll
75		* @param array $options
76		*/
77	35	public function delete(PersistentCollectionInterface $coll, array $options)
78		{
79	35	$mapping = $coll->getMapping();
80	35	if ($mapping['isInverseSide']) {
81		return; // ignore inverse side
82		}
83	35	if (CollectionHelper::isAtomic($mapping['strategy'])) {
84		throw new \UnexpectedValueException($mapping['strategy'] . ' delete collection strategy should have been handled by DocumentPersister. Please report a bug in issue tracker');
85		}
86	35	list($propertyPath, $parent) = $this->getPathAndParent($coll);
87	35	$query = array('$unset' => array($propertyPath => true));
88	35	$this->executeQuery($parent, $query, $options);
89	34	}
90
91		/**
92		* Updates a PersistentCollection instance deleting removed rows and
93		* inserting new rows.
94		*
95		* @param PersistentCollectionInterface $coll
96		* @param array $options
97		*/
98	100	public function update(PersistentCollectionInterface $coll, array $options)
99		{
100	100	$mapping = $coll->getMapping();
101
102	100	if ($mapping['isInverseSide']) {
103		return; // ignore inverse side
104		}
105
106	100	switch ($mapping['strategy']) {
107	100	case ClassMetadataInfo::STORAGE_STRATEGY_ATOMIC_SET:
108	100	case ClassMetadataInfo::STORAGE_STRATEGY_ATOMIC_SET_ARRAY:
109		throw new \UnexpectedValueException($mapping['strategy'] . ' update collection strategy should have been handled by DocumentPersister. Please report a bug in issue tracker');
110
111	100	case ClassMetadataInfo::STORAGE_STRATEGY_SET:
112	100	case ClassMetadataInfo::STORAGE_STRATEGY_SET_ARRAY:
113	11	$this->setCollection($coll, $options);
114	11	break;
115
116	90	case ClassMetadataInfo::STORAGE_STRATEGY_ADD_TO_SET:
117	90	case ClassMetadataInfo::STORAGE_STRATEGY_PUSH_ALL:
118	90	$coll->initialize();
119	90	$this->deleteElements($coll, $options);
120	90	$this->insertElements($coll, $options);
121	89	break;
122
123		default:
124		throw new \UnexpectedValueException('Unsupported collection strategy: ' . $mapping['strategy']);
125	99	}
126	99	}
127
128		/**
129		* Sets a PersistentCollection instance.
130		*
131		* This method is intended to be used with the "set" or "setArray"
132		* strategies. The "setArray" strategy will ensure that the collection is
133		* set as a BSON array, which means the collection elements will be
134		* reindexed numerically before storage.
135		*
136		* @param PersistentCollectionInterface $coll
137		* @param array $options
138		*/
139	11	private function setCollection(PersistentCollectionInterface $coll, array $options)
140		{
141	11	list($propertyPath, $parent) = $this->getPathAndParent($coll);
142	11	$coll->initialize();
143	11	$mapping = $coll->getMapping();
144	11	$setData = $this->pb->prepareAssociatedCollectionValue($coll, CollectionHelper::usesSet($mapping['strategy']));
145	11	$query = array('$set' => array($propertyPath => $setData));
146	11	$this->executeQuery($parent, $query, $options);
147	11	}
148
149		/**
150		* Deletes removed elements from a PersistentCollection instance.
151		*
152		* This method is intended to be used with the "pushAll" and "addToSet"
153		* strategies.
154		*
155		* @param PersistentCollectionInterface $coll
156		* @param array $options
157		*/
158	90	private function deleteElements(PersistentCollectionInterface $coll, array $options)
159		{
160	90	$deleteDiff = $coll->getDeleteDiff();
161
162	90	if (empty($deleteDiff)) {
163	70	return;
164		}
165
166	29	list($propertyPath, $parent) = $this->getPathAndParent($coll);
167
168	29	$query = array('$unset' => array());
169
170	29	foreach ($deleteDiff as $key => $document) {
171	29	$query['$unset'][$propertyPath . '.' . $key] = true;
172	29	}
173
174	29	$this->executeQuery($parent, $query, $options);
175
176		/**
177		* @todo This is a hack right now because we don't have a proper way to
178		* remove an element from an array by its key. Unsetting the key results
179		* in the element being left in the array as null so we have to pull
180		* null values.
181		*/
182	29	$this->executeQuery($parent, array('$pull' => array($propertyPath => null)), $options);
183	29	}
184
185		/**
186		* Inserts new elements for a PersistentCollection instance.
187		*
188		* This method is intended to be used with the "pushAll" and "addToSet"
189		* strategies.
190		*
191		* @param PersistentCollectionInterface $coll
192		* @param array $options
193		*/
194	90	private function insertElements(PersistentCollectionInterface $coll, array $options)
195		{
196	90	$insertDiff = $coll->getInsertDiff();
197
198	90	if (empty($insertDiff)) {
199	21	return;
200		}
201
202	75	$mapping = $coll->getMapping();
203	75	list($propertyPath, $parent) = $this->getPathAndParent($coll);
204
205	75	$pb = $this->pb;
206
207	75	$callback = isset($mapping['embedded'])
208		? function($v) use ($pb, $mapping) { return $pb->prepareEmbeddedDocumentValue($mapping, $v); }
209		: function($v) use ($pb, $mapping) { return $pb->prepareReferencedDocumentValue($mapping, $v); };
210
211	75	$value = array_values(array_map($callback, $insertDiff));
212
213	75	if ($mapping['strategy'] === ClassMetadataInfo::STORAGE_STRATEGY_ADD_TO_SET) {
214	6	$value = array('$each' => $value);
215	6	}
216
217	75	$query = array('$' . $mapping['strategy'] => array($propertyPath => $value));
218
219	75	$this->executeQuery($parent, $query, $options);
220	74	}
221
222		/**
223		* Gets the parent information for a given PersistentCollection. It will
224		* retrieve the top-level persistent Document that the PersistentCollection
225		* lives in. We can use this to issue queries when updating a
226		* PersistentCollection that is multiple levels deep inside an embedded
227		* document.
228		*
229		* <code>
230		* list($path, $parent) = $this->getPathAndParent($coll)
231		* </code>
232		*
233		* @param PersistentCollectionInterface $coll
234		* @return array $pathAndParent
235		*/
236	111	private function getPathAndParent(PersistentCollectionInterface $coll)
237		{
238	111	$mapping = $coll->getMapping();
239	111	$fields = array();
240	111	$parent = $coll->getOwner();
241	111	while (null !== ($association = $this->uow->getParentAssociation($parent))) {
242	15	list($m, $owner, $field) = $association;
243	15	if (isset($m['reference'])) {
244		break;
245		}
246	15	$parent = $owner;
247	15	$fields[] = $field;
248	15	}
249	111	$propertyPath = implode('.', array_reverse($fields));
250	111	$path = $mapping['name'];
251	111	if ($propertyPath) {
252	15	$path = $propertyPath . '.' . $path;
253	15	}
254	111	return array($path, $parent);
255		}
256
257		/**
258		* Executes a query updating the given document.
259		*
260		* @param object $document
261		* @param array $newObj
262		* @param array $options
263		*/
264	111	private function executeQuery($document, array $newObj, array $options)
265		{
266	111	$className = get_class($document);
267	111	$class = $this->dm->getClassMetadata($className);
268	111	$id = $class->getDatabaseIdentifierValue($this->uow->getDocumentIdentifier($document));
269	111	$query = array('_id' => $id);
270	111	if ($class->isVersioned) {
271	5	$query[$class->fieldMappings[$class->versionField]['name']] = $class->reflFields[$class->versionField]->getValue($document);
272	5	}
273	111	$collection = $this->dm->getDocumentCollection($className);
274	111	$result = $collection->update($query, $newObj, $options);
275	111	if ($class->isVersioned && ! $result['n']) {
276	2	throw LockException::lockFailed($document);
277		}
278	109	}
279		}
280

doctrine / mongodb-odm

Pull Request — master (#1660)

CollectionPersister::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like