/** * {@inheritDoc} */ public function createProxyDefinition($className) { /* @var $classMetadata \Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo */ $classMetadata = $this->metadataFactory->getMetadataFor($className); $documentPersister = $this->uow->getDocumentPersister($className); $reflectionId = $classMetadata->reflFields[$classMetadata->identifier]; return new ProxyDefinition(ClassUtils::generateProxyClassName($className, $this->proxyNamespace), $classMetadata->getIdentifierFieldNames(), $classMetadata->getReflectionProperties(), $this->createInitializer($classMetadata, $documentPersister, $reflectionId), $this->createCloner($classMetadata, $documentPersister, $reflectionId)); }
/** * Create all the mapped document databases in the metadata factory. */ public function createDatabases() { foreach ($this->metadataFactory->getAllMetadata() as $class) { if ($class->isMappedSuperclass || $class->isEmbeddedDocument) { continue; } $this->createDocumentDatabase($class->name); } }
/** * Ensure collections are sharded for all documents that can be loaded with the * metadata factory. * * @param array $indexOptions Options for `ensureIndex` command. It's performed on an existing collections * * @throws MongoDBException */ public function ensureSharding(array $indexOptions = array()) { foreach ($this->metadataFactory->getAllMetadata() as $class) { if ($class->isMappedSuperclass || !$class->isSharded()) { continue; } $this->ensureDocumentSharding($class->name, $indexOptions); } }
public function setUp() { $this->dm = $this->getMockDocumentManager(); $cmf = new ClassMetadataFactory(); $cmf->setConfiguration($this->dm->getConfiguration()); $cmf->setDocumentManager($this->dm); $map = array(); foreach ($cmf->getAllMetadata() as $cm) { $this->documentCollections[$cm->name] = $this->getMockCollection(); $this->documentDatabases[$cm->name] = $this->getMockDatabase(); $this->classMetadatas[$cm->name] = $cm; } $this->dm->unitOfWork = $this->getMockUnitOfWork(); $this->dm->metadataFactory = $cmf; $this->dm->documentCollections = $this->documentCollections; $this->dm->documentDatabases = $this->documentDatabases; $this->schemaManager = new SchemaManager($this->dm, $cmf); $this->dm->schemaManager = $this->schemaManager; }
/** * Gets a reference to the document identified by the given type and identifier * without actually loading it. * * If partial objects are allowed, this method will return a partial object that only * has its identifier populated. Otherwise a proxy is returned that automatically * loads itself on first access. * * @return object The document reference. */ public function getReference($documentName, $identifier) { $class = $this->_metadataFactory->getMetadataFor($documentName); // Check identity map first, if its already in there just return it. if ($document = $this->_unitOfWork->tryGetById($identifier, $class->rootDocumentName)) { return $document; } $document = $this->_proxyFactory->getProxy($class->name, $identifier); $this->_unitOfWork->registerManaged($document, $identifier, array()); return $document; }
/** * Gets a partial reference to the document identified by the given type and identifier * without actually loading it, if the document is not yet loaded. * * The returned reference may be a partial object if the document is not yet loaded/managed. * If it is a partial object it will not initialize the rest of the document state on access. * Thus you can only ever safely access the identifier of an document obtained through * this method. * * The use-cases for partial references involve maintaining bidirectional associations * without loading one side of the association or to update an document without loading it. * Note, however, that in the latter case the original (persistent) document data will * never be visible to the application (especially not event listeners) as it will * never be loaded in the first place. * * @param string $documentName The name of the document type. * @param mixed $identifier The document identifier. * @return object The (partial) document reference. */ public function getPartialReference($documentName, $identifier) { $class = $this->metadataFactory->getMetadataFor($documentName); // Check identity map first, if its already in there just return it. if ($document = $this->unitOfWork->tryGetById($identifier, $class->rootDocumentName)) { return $document; } $document = $class->newInstance(); $class->setIdentifierValue($document, $identifier); $this->unitOfWork->registerManaged($document, $identifier, array()); return $document; }
public function testHasGetMetadata_NamespaceSeperatorIsNotNormalized() { require_once __DIR__ . "/Documents/GlobalNamespaceDocument.php"; $driver = AnnotationDriver::create(__DIR__ . '/Documents'); $dm = $this->getMockDocumentManager($driver); $cmf = new ClassMetadataFactory(); $cmf->setConfiguration($dm->getConfiguration()); $cmf->setDocumentManager($dm); $m1 = $cmf->getMetadataFor("DoctrineGlobal_Article"); $h1 = $cmf->hasMetadataFor("DoctrineGlobal_Article"); $h2 = $cmf->hasMetadataFor("\\DoctrineGlobal_Article"); $m2 = $cmf->getMetadataFor("\\DoctrineGlobal_Article"); $this->assertNotSame($m1, $m2); $this->assertFalse($h2); $this->assertTrue($h1); }
/** * {@inheritdoc} */ public function setDocumentManager(DocumentManager $dm) { parent::setDocumentManager($dm); $this->documentManager = $dm; }
public function testShardKeyCollectionPerClassInheritanceOverriding() { $class = $this->factory->getMetadataFor(ShardedCollectionPerClass3::class); $this->assertTrue($class->isSharded()); $this->assertEquals(array('keys' => array('_id' => 'hashed'), 'options' => array()), $class->getShardKey()); }