Returns the MongoCollection instance for a class.
| public getDocumentCollection ( string $className ) : Doctrine\MongoDB\Collection | ||
| $className | string | The class name. |
| return | Doctrine\MongoDB\Collection | |
protected function tearDown()
{
$documentClasses = array('Saxulum\\Tests\\DoctrineMongodbOdmManagerRegistry\\Document\\Document', 'Saxulum\\Tests\\DoctrineMongodbOdmManagerRegistry\\Document\\Category');
foreach ($documentClasses as $class) {
$this->dm->getDocumentCollection($class)->drop();
}
parent::tearDown();
}
protected function tearDown()
{
$documentClasses = array('Doctrine\\Bundle\\MongoDBBundle\\Tests\\Fixtures\\Form\\Document', 'Doctrine\\Bundle\\MongoDBBundle\\Tests\\Fixtures\\Form\\Category', 'Doctrine\\Bundle\\MongoDBBundle\\Tests\\Fixtures\\Form\\Guesser');
foreach ($documentClasses as $class) {
$this->dm->getDocumentCollection($class)->drop();
}
parent::tearDown();
}
protected function tearDown()
{
$documentClasses = [Document::class, Category::class];
foreach ($documentClasses as $class) {
$this->dm->getDocumentCollection($class)->drop();
}
parent::tearDown();
}
/**
* {@inheritDoc}
*/
protected function batchInsertPendingVersions(array $pendingVersions)
{
$mongodbVersions = [];
foreach ($pendingVersions as $pendingVersion) {
$mongodbVersions[] = $this->normalizer->normalize($pendingVersion, VersionNormalizer::FORMAT);
}
$collection = $this->documentManager->getDocumentCollection($this->versionClass);
$collection->batchInsert($mongodbVersions);
}
/**
*
* @param \Ricklab\Location\Point $point
* @param int $limit Limit the results to a number
* @param int $offset Start from this item
* @return \Doctrine\MongoDB\ArrayIterator
*/
public function getLocationsAround(Loc\Point $point, $limit, $offset = 0)
{
$locations = $this->doctrine->getDocumentCollection('CraftLocationBundle:Location')->aggregate(['$geoNear' => ['near' => $point->jsonSerialize(), 'limit' => (int) $limit, 'skip' => $offset, 'spherical' => true, 'distanceField' => 'distance']]);
/* $locations = $this->getMongoLocationCollection()
->createQueryBuilder()
->geoNear($x, $y)
->limit((int) $limit)
->skip($offset)->getQuery(); */
return $locations;
}
/**
* {@inheritdoc}
*/
public function saveAll(array $versions, array $options = [])
{
$normalizedVersions = [];
foreach ($versions as $version) {
$normalizedVersions[] = $this->normalizer->normalize($version, VersionNormalizer::FORMAT);
}
if (0 < count($normalizedVersions)) {
$collection = $this->documentManager->getDocumentCollection($this->versionClass);
$collection->batchInsert($normalizedVersions);
}
}
function let(DocumentManager $documentManager, PendingMassPersister $pendingPersister, NormalizerInterface $normalizer, EventDispatcherInterface $eventDispatcher, MongoObjectsFactory $mongoFactory, StepExecution $stepExecution, Collection $collection, CacheClearer $clearer)
{
$documentManager->getDocumentCollection('pim_product')->willReturn($collection);
$collection->getName()->willReturn('pim_product_collection');
$this->beConstructedWith($documentManager, $pendingPersister, $normalizer, $eventDispatcher, $mongoFactory, 'pim_product', $clearer);
$this->setStepExecution($stepExecution);
}
/**
* Save the completenesses data for the product directly to MongoDB.
*
* @param string $productId
* @param array $compData
*/
protected function saveCompletenesses($productId, array $compData)
{
$completenesses = $compData['completenesses'];
$all = $compData['all'];
$collection = $this->documentManager->getDocumentCollection($this->productClass);
$query = ['_id' => $productId];
$options = ['multiple' => false];
if ($all) {
$compObjects = [];
$normalizedComps = [];
foreach ($completenesses as $key => $value) {
$compObject = $value['object'];
$compObject['_id'] = new \MongoId();
$compObjects[] = $compObject;
$normalizedComps[$key] = $value['ratio'];
}
$normalizedComps = ['normalizedData.completenesses' => $normalizedComps];
$compObject = ['$set' => ['completenesses' => $compObjects]];
$collection->update($query, $compObject, $options);
$normalizedComp = ['$set' => $normalizedComps];
$collection->update($query, $normalizedComp, $options);
} else {
foreach ($completenesses as $key => $value) {
$compObject = ['$push' => ['completenesses' => $value['object']]];
$collection->update($query, $compObject, $options);
$normalizedComp = ['$set' => ['normalizedData.completenesses.' . $key => $value['ratio']]];
$collection->update($query, $normalizedComp, $options);
}
}
}
public function loadCollection(PersistentCollection $collection)
{
$mapping = $collection->getMapping();
$cmd = $this->dm->getConfiguration()->getMongoCmd();
$groupedIds = array();
foreach ($collection->getReferences() as $reference) {
$className = $this->dm->getClassNameFromDiscriminatorValue($mapping, $reference);
$id = $reference[$cmd . 'id'];
$reference = $this->dm->getReference($className, (string) $id);
$collection->add($reference);
if ($reference instanceof Proxy && ! $reference->__isInitialized__) {
if ( ! isset($groupedIds[$className])) {
$groupedIds[$className] = array();
}
$groupedIds[$className][] = $id;
}
}
foreach ($groupedIds as $className => $ids) {
$mongoCollection = $this->dm->getDocumentCollection($className);
$data = $mongoCollection->find(array('_id' => array($cmd . 'in' => $ids)));
$hints = array(Builder::HINT_REFRESH => true);
foreach ($data as $id => $documentData) {
$document = $this->uow->getOrCreateDocument($className, $documentData, $hints);
}
}
}
/**
* Ensure sharding for collection by document name.
*
* @param string $documentName
* @param array $indexOptions Options for `ensureIndex` command. It's performed on an existing collections.
*
* @throws MongoDBException
*/
public function ensureDocumentSharding($documentName, array $indexOptions = array())
{
$class = $this->dm->getClassMetadata($documentName);
if (!$class->isSharded()) {
return;
}
$this->enableShardingForDbByDocumentName($documentName);
$try = 0;
do {
$result = $this->runShardCollectionCommand($documentName);
$done = true;
// Need to check error message because MongoDB 3.0 does not return a code for this error
if ($result['ok'] != 1 && strpos($result['errmsg'], 'please create an index that starts') !== false) {
// The proposed key is not returned when using mongo-php-adapter with ext-mongodb.
// See https://github.com/mongodb/mongo-php-driver/issues/296 for details
if (isset($result['proposedKey'])) {
$key = $result['proposedKey'];
} else {
$key = $this->dm->getClassMetadata($documentName)->getShardKey()['keys'];
}
$this->dm->getDocumentCollection($documentName)->ensureIndex($key, $indexOptions);
$done = false;
$try++;
}
} while (!$done && $try < 2);
// Starting with MongoDB 3.2, this command returns code 20 when a collection is already sharded.
// For older MongoDB versions, check the error message
if ($result['ok'] == 1 || isset($result['code']) && $result['code'] == 20 || $result['errmsg'] == 'already sharded') {
return;
}
throw MongoDBException::failedToEnsureDocumentSharding($documentName, $result['errmsg']);
}
private function loadReferenceManyCollection(PersistentCollection $collection)
{
$mapping = $collection->getMapping();
$cmd = $this->cmd;
$groupedIds = array();
foreach ($collection->getMongoData() as $reference) {
$className = $this->dm->getClassNameFromDiscriminatorValue($mapping, $reference);
$mongoId = $reference[$cmd . 'id'];
$id = (string) $mongoId;
$reference = $this->dm->getReference($className, $id);
$collection->add($reference);
if ($reference instanceof Proxy && !$reference->__isInitialized__) {
if (!isset($groupedIds[$className])) {
$groupedIds[$className] = array();
}
$groupedIds[$className][] = $mongoId;
}
}
foreach ($groupedIds as $className => $ids) {
$class = $this->dm->getClassMetadata($className);
$mongoCollection = $this->dm->getDocumentCollection($className);
$data = $mongoCollection->find(array('_id' => array($cmd . 'in' => $ids)));
foreach ($data as $documentData) {
$document = $this->uow->getById((string) $documentData['_id'], $class->rootDocumentName);
$data = $this->hydratorFactory->hydrate($document, $documentData);
$this->uow->setOriginalDocumentData($document, $data);
}
}
}
/**
* {@inheritdoc}
*/
public function write(array $products)
{
$this->collection = $this->documentManager->getDocumentCollection($this->productClass);
$productsToInsert = [];
$productsToUpdate = [];
foreach ($products as $product) {
if (null === $product->getId()) {
$productsToInsert[] = $product;
$product->setId($this->mongoFactory->createMongoId());
} else {
$productsToUpdate[] = $product;
}
}
$this->eventDispatcher->dispatch(self::PRE_INSERT, new GenericEvent($productsToInsert));
$this->eventDispatcher->dispatch(self::PRE_UPDATE, new GenericEvent($productsToUpdate));
$insertDocs = $this->getDocsFromProducts($productsToInsert);
$updateDocs = $this->getDocsFromProducts($productsToUpdate);
if (count($insertDocs) > 0) {
$this->insertDocuments($insertDocs);
}
if (count($updateDocs) > 0) {
$this->updateDocuments($updateDocs);
}
$this->pendingPersister->persistPendingVersions($products);
$this->eventDispatcher->dispatch(self::POST_INSERT, new GenericEvent($productsToInsert));
$this->eventDispatcher->dispatch(self::POST_UPDATE, new GenericEvent($productsToUpdate));
$this->documentManager->clear();
$this->cacheClearer->clear();
}
/**
* Delete the given document's indexes.
*
* @param string $documentName
* @throws \InvalidArgumentException
*/
public function deleteDocumentIndexes($documentName)
{
$class = $this->dm->getClassMetadata($documentName);
if ($class->isMappedSuperclass || $class->isEmbeddedDocument) {
throw new \InvalidArgumentException('Cannot delete document indexes for mapped super classes or embedded documents.');
}
$this->dm->getDocumentCollection($documentName)->deleteIndexes();
}
/**
* Executes a query updating the given document.
*
* @param object $document
* @param array $query
* @param array $options
*/
private function executeQuery($document, array $query, array $options)
{
$className = get_class($document);
$class = $this->dm->getClassMetadata($className);
$findQuery = $this->getQueryForDocument($class, $document);
$collection = $this->dm->getDocumentCollection($className);
$collection->update($findQuery, $query, $options);
}
/**
* Initializes a new BasicDocumentPersister instance.
*
* @param Doctrine\ODM\MongoDB\DocumentManager $dm
* @param Doctrine\ODM\MongoDB\Mapping\ClassMetadata $class
*/
public function __construct(DocumentManager $dm, ClassMetadata $class)
{
$this->_dm = $dm;
$this->_uow = $dm->getUnitOfWork();
$this->_class = $class;
$this->_documentName = $class->getName();
$this->_collection = $dm->getDocumentCollection($class->name);
}
/**
* Executes a query updating the given document.
*
* @param object $document
* @param array $query
* @param array $options
*/
private function executeQuery($document, array $query, array $options)
{
$className = get_class($document);
$class = $this->dm->getClassMetadata($className);
$id = $class->getDatabaseIdentifierValue($this->uow->getDocumentIdentifier($document));
$collection = $this->dm->getDocumentCollection($className);
$collection->update(array('_id' => $id), $query, $options);
}
/**
* Get the last available version for the provided document
*
* @param VersionableInterface $versionable
*
* @return Version
*/
protected function getPreviousVersion(VersionableInterface $versionable)
{
$versionCollection = $this->documentManager->getDocumentCollection($this->versionClass);
$resourceName = get_class($versionable);
$resourceId = $versionable->getId();
$version = $this->documentManager->createQueryBuilder($this->versionClass)->field('resourceName')->equals($resourceName)->field('resourceId')->equals($resourceId)->limit(1)->sort('loggedAt', 'desc')->getQuery()->getSingleResult();
return $version;
}
private function loadReferenceManyCollectionOwningSide(PersistentCollection $collection)
{
$hints = $collection->getHints();
$mapping = $collection->getMapping();
$cmd = $this->cmd;
$groupedIds = array();
foreach ($collection->getMongoData() as $key => $reference) {
if (isset($mapping['simple']) && $mapping['simple']) {
$className = $mapping['targetDocument'];
$mongoId = $reference;
} else {
$className = $this->dm->getClassNameFromDiscriminatorValue($mapping, $reference);
$mongoId = $reference[$cmd . 'id'];
}
$id = (string) $mongoId;
if (!$id) {
continue;
}
$reference = $this->dm->getReference($className, $id);
if ($mapping['strategy'] === 'set') {
$collection->set($key, $reference);
} else {
$collection->add($reference);
}
if ($reference instanceof Proxy && !$reference->__isInitialized__) {
if (!isset($groupedIds[$className])) {
$groupedIds[$className] = array();
}
$groupedIds[$className][] = $mongoId;
}
}
foreach ($groupedIds as $className => $ids) {
$class = $this->dm->getClassMetadata($className);
$mongoCollection = $this->dm->getDocumentCollection($className);
$criteria = array_merge(array('_id' => array($cmd . 'in' => $ids)), $this->dm->getFilterCollection()->getFilterCriteria($class), isset($mapping['criteria']) ? $mapping['criteria'] : array());
$cursor = $mongoCollection->find($criteria);
if (isset($mapping['sort'])) {
$cursor->sort($mapping['sort']);
}
if (isset($mapping['limit'])) {
$cursor->limit($mapping['limit']);
}
if (isset($mapping['skip'])) {
$cursor->skip($mapping['skip']);
}
if (isset($hints[Query::HINT_SLAVE_OKAY])) {
$cursor->slaveOkay(true);
}
$documents = $cursor->toArray();
foreach ($documents as $documentData) {
$document = $this->uow->getById((string) $documentData['_id'], $class->rootDocumentName);
$data = $this->hydratorFactory->hydrate($document, $documentData);
$this->uow->setOriginalDocumentData($document, $data);
$document->__isInitialized__ = true;
}
}
}
/**
* Find all common attribute ids with values from a list of product ids
* Only exists for ODM repository
*
* @param array $productIds
*
* @return array
*/
protected function findValuesCommonAttributeIds(array $productIds)
{
$collection = $this->dm->getDocumentCollection($this->documentName);
$expr = new Expr($this->dm);
$class = $this->dm->getClassMetadata($this->documentName);
$expr->setClassMetadata($class);
$expr->field('_id')->in($productIds);
$pipeline = [['$match' => $expr->getQuery()], ['$unwind' => '$values'], ['$group' => ['_id' => ['id' => '$_id', 'family' => '$family'], 'attribute' => ['$addToSet' => '$values.attribute']]]];
return $collection->aggregate($pipeline)->toArray();
}
/**
* Gets or creates a Persister instance for the given class name.
*
* @param string $className
* @return Persister $persister
*/
public function getDocumentPersister($className)
{
if (isset($this->persisters[$className])) {
return $this->persisters[$className];
}
$class = $this->dm->getClassMetadata($className);
$collection = $this->dm->getDocumentCollection($className);
$persister = $this->dm->getUnitOfWork()->getDocumentPersister($className);
$this->persisters[$className] = new Persister($this->configuration, $class, $collection, $persister);
return $this->persisters[$className];
}
private function setDocumentName($documentName)
{
if (is_array($documentName)) {
$documentNames = $documentName;
$documentName = $documentNames[0];
$discriminatorField = $this->dm->getClassMetadata($documentName)->discriminatorField['name'];
$discriminatorValues = $this->getDiscriminatorValues($documentNames);
$this->field($discriminatorField)->in($discriminatorValues);
}
if ($documentName !== null) {
$this->collection = $this->dm->getDocumentCollection($documentName);
$this->database = $this->collection->getDatabase();
$this->class = $this->dm->getClassMetadata($documentName);
}
}
/**
* 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->versionField] = $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);
}
}
/**
* @param string[]|string $documentName an array of document names or just one.
*/
private function setDocumentName($documentName)
{
if (is_array($documentName)) {
$documentNames = $documentName;
$documentName = $documentNames[0];
$discriminatorField = $this->dm->getClassMetadata($documentName)->discriminatorField;
$discriminatorValues = $this->getDiscriminatorValues($documentNames);
$this->field($discriminatorField)->in($discriminatorValues);
}
if ($documentName !== null) {
$this->collection = $this->dm->getDocumentCollection($documentName);
$this->class = $this->dm->getClassMetadata($documentName);
// Expr also needs to know
$this->expr->setClassMetadata($this->class);
}
}
/** @inheritDoc */
public function generate(DocumentManager $dm, $document)
{
$className = get_class($document);
$db = $dm->getDocumentDatabase($className);
$coll = $dm->getDocumentCollection($className);
$query = array('_id' => $coll->getName());
$newObj = array('$inc' => array('current_id' => 1));
$command = array();
$command['findandmodify'] = 'doctrine_increment_ids';
$command['query'] = $query;
$command['update'] = $newObj;
$command['upsert'] = true;
$command['new'] = true;
$result = $db->command($command);
return $result['value']['current_id'];
}
private function initialize()
{
if (!$this->initialized) {
if ($this->isDirty) {
// Has NEW objects added through add(). Remember them.
$newObjects = $this->coll->toArray();
}
$this->coll->clear();
$groupedIds = array();
foreach ($this->references as $reference) {
$className = $this->dm->getClassNameFromDiscriminatorValue($this->mapping, $reference);
if (!isset($groupedIds[$className])) {
$groupedIds[$className] = array();
}
$id = $reference[$this->cmd . 'id'];
$groupedIds[$className][] = $id;
$reference = $this->dm->getReference($className, (string) $id);
$this->add($reference);
}
foreach ($groupedIds as $className => $ids) {
$collection = $this->dm->getDocumentCollection($className);
$data = $collection->find(array('_id' => array($this->cmd . 'in' => $ids)));
$hints = array(Query::HINT_REFRESH => Query::HINT_REFRESH);
foreach ($data as $id => $documentData) {
$document = $this->dm->getUnitOfWork()->getOrCreateDocument($className, $documentData, $hints);
if ($document instanceof Proxy) {
$document->__isInitialized__ = true;
unset($document->__dm);
unset($document->__identifier);
}
}
}
$this->takeSnapshot();
// Reattach NEW objects added through add(), if any.
if (isset($newObjects)) {
foreach ($newObjects as $obj) {
$this->coll->add($obj);
}
$this->isDirty = true;
}
$this->initialized = true;
}
}
/**
* @param string[]|string $documentName an array of document names or just one.
*/
private function setDocumentName($documentName)
{
if (is_array($documentName)) {
$documentNames = $documentName;
$documentName = $documentNames[0];
$metadata = $this->dm->getClassMetadata($documentName);
$discriminatorField = $metadata->discriminatorField;
$discriminatorValues = $this->getDiscriminatorValues($documentNames);
// If a defaultDiscriminatorValue is set and it is among the discriminators being queries, add NULL to the list
if ($metadata->defaultDiscriminatorValue && array_search($metadata->defaultDiscriminatorValue, $discriminatorValues) !== false) {
$discriminatorValues[] = null;
}
$this->field($discriminatorField)->in($discriminatorValues);
}
if ($documentName !== null) {
$this->collection = $this->dm->getDocumentCollection($documentName);
$this->class = $this->dm->getClassMetadata($documentName);
// Expr also needs to know
$this->expr->setClassMetadata($this->class);
}
}
/**
* Ensure sharding for collection by document name.
*
* @param string $documentName
* @param array $indexOptions Options for `ensureIndex` command. It's performed on an existing collections.
*
* @throws MongoDBException
*/
public function ensureDocumentSharding($documentName, array $indexOptions = array())
{
$class = $this->dm->getClassMetadata($documentName);
if (!$class->isSharded()) {
return;
}
$this->enableShardingForDbByDocumentName($documentName);
do {
$result = $this->runShardCollectionCommand($documentName);
$done = true;
$try = 0;
if ($result['ok'] != 1 && isset($result['proposedKey'])) {
$this->dm->getDocumentCollection($documentName)->ensureIndex($result['proposedKey'], $indexOptions);
$done = false;
$try++;
}
} while (!$done && $try < 2);
if ($result['ok'] != 1 && $result['errmsg'] !== 'already sharded') {
throw MongoDBException::failedToEnsureDocumentSharding($documentName, $result['errmsg']);
}
}
/**
* @param PersistentCollection $collection
* @param array $groupedIds
*
* @throws \Doctrine\ODM\MongoDB\MongoDBException
*/
private function loadActualDataForSortedReferenceManyCollectionByIds(PersistentCollection $collection, array $groupedIds)
{
$mapping = $collection->getMapping();
$hints = $collection->getHints();
foreach ($groupedIds as $className => $ids) {
$class = $this->dm->getClassMetadata($className);
$mongoCollection = $this->dm->getDocumentCollection($className);
$criteria = $this->cm->merge(array('_id' => array('$in' => array_values($ids))), $this->dm->getFilterCollection()->getFilterCriteria($class), isset($mapping['criteria']) ? $mapping['criteria'] : array());
$criteria = $this->uow->getDocumentPersister($className)->prepareQueryOrNewObj($criteria);
$cursor = $mongoCollection->find($criteria);
if (isset($mapping['sort'])) {
$cursor->sort($mapping['sort']);
}
if (isset($mapping['limit'])) {
$cursor->limit($mapping['limit']);
}
if (isset($mapping['skip'])) {
$cursor->skip($mapping['skip']);
}
if (!empty($hints[Query::HINT_SLAVE_OKAY])) {
$cursor->slaveOkay(true);
}
if (!empty($hints[Query::HINT_READ_PREFERENCE])) {
$cursor->setReadPreference($hints[Query::HINT_READ_PREFERENCE], $hints[Query::HINT_READ_PREFERENCE_TAGS]);
}
$documents = $cursor->toArray(false);
foreach ($documents as $documentData) {
$docId = $documentData['_id'];
$document = $this->uow->getById($docId, $class);
$data = $this->hydratorFactory->hydrate($document, $documentData);
$this->uow->setOriginalDocumentData($document, $data);
$document->__isInitialized__ = true;
$collection->add($document);
}
}
}
private function loadReferenceManyCollectionOwningSide(PersistentCollection $collection)
{
$hints = $collection->getHints();
$mapping = $collection->getMapping();
$groupedIds = array();
$sorted = isset($mapping['sort']) && $mapping['sort'];
foreach ($collection->getMongoData() as $key => $reference) {
if (isset($mapping['simple']) && $mapping['simple']) {
$className = $mapping['targetDocument'];
$mongoId = $reference;
} else {
$className = $this->uow->getClassNameForAssociation($mapping, $reference);
$mongoId = $reference['$id'];
}
$id = $this->dm->getClassMetadata($className)->getPHPIdentifierValue($mongoId);
// create a reference to the class and id
$reference = $this->dm->getReference($className, $id);
// no custom sort so add the references right now in the order they are embedded
if (!$sorted) {
if (CollectionHelper::isHash($mapping['strategy'])) {
$collection->set($key, $reference);
} else {
$collection->add($reference);
}
}
// only query for the referenced object if it is not already initialized or the collection is sorted
if ($reference instanceof Proxy && !$reference->__isInitialized__ || $sorted) {
$groupedIds[$className][] = $mongoId;
}
}
foreach ($groupedIds as $className => $ids) {
$class = $this->dm->getClassMetadata($className);
$mongoCollection = $this->dm->getDocumentCollection($className);
$criteria = $this->cm->merge(array('_id' => array('$in' => array_values($ids))), $this->dm->getFilterCollection()->getFilterCriteria($class), isset($mapping['criteria']) ? $mapping['criteria'] : array());
$criteria = $this->uow->getDocumentPersister($className)->prepareQueryOrNewObj($criteria);
$cursor = $mongoCollection->find($criteria);
if (isset($mapping['sort'])) {
$cursor->sort($mapping['sort']);
}
if (isset($mapping['limit'])) {
$cursor->limit($mapping['limit']);
}
if (isset($mapping['skip'])) {
$cursor->skip($mapping['skip']);
}
if (!empty($hints[Query::HINT_SLAVE_OKAY])) {
$cursor->slaveOkay(true);
}
if (!empty($hints[Query::HINT_READ_PREFERENCE])) {
$cursor->setReadPreference($hints[Query::HINT_READ_PREFERENCE], $hints[Query::HINT_READ_PREFERENCE_TAGS]);
}
$documents = $cursor->toArray(false);
foreach ($documents as $documentData) {
$document = $this->uow->getById($documentData['_id'], $class);
$data = $this->hydratorFactory->hydrate($document, $documentData);
$this->uow->setOriginalDocumentData($document, $data);
$document->__isInitialized__ = true;
if ($sorted) {
$collection->add($document);
}
}
}
}
/**
* Initializes a new DocumentPersister instance.
*
* @param Doctrine\ODM\MongoDB\Persisters\PersistenceBuilder $pb
* @param Doctrine\ODM\MongoDB\DocumentManager $dm
* @param Doctrine\Common\EventManager $evm
* @param Doctrine\ODM\MongoDB\UnitOfWork $uow
* @param Doctrine\ODM\MongoDB\Hydrator\HydratorFactory $hydratorFactory
* @param Doctrine\ODM\MongoDB\Mapping\ClassMetadata $class
* @param string $cmd
*/
public function __construct(PersistenceBuilder $pb, DocumentManager $dm, EventManager $evm, UnitOfWork $uow, HydratorFactory $hydratorFactory, ClassMetadata $class, $cmd)
{
$this->pb = $pb;
$this->dm = $dm;
$this->evm = $evm;
$this->cmd = $cmd;
$this->uow = $uow;
$this->hydratorFactory = $hydratorFactory;
$this->class = $class;
$this->collection = $dm->getDocumentCollection($class->name);
}