vendor/doctrine/mongodb-odm/lib/Doctrine/ODM/MongoDB/DocumentManager.php line 294

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ODM\MongoDB;
  7. use Doctrine\Common\EventManager;
  8. use Doctrine\ODM\MongoDB\Hydrator\HydratorFactory;
  9. use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
  10. use Doctrine\ODM\MongoDB\Mapping\ClassMetadataFactoryInterface;
  11. use Doctrine\ODM\MongoDB\Mapping\MappingException;
  12. use Doctrine\ODM\MongoDB\Proxy\Factory\LazyGhostProxyFactory;
  13. use Doctrine\ODM\MongoDB\Proxy\Factory\ProxyFactory;
  14. use Doctrine\ODM\MongoDB\Proxy\Factory\StaticProxyFactory;
  15. use Doctrine\ODM\MongoDB\Proxy\Resolver\CachingClassNameResolver;
  16. use Doctrine\ODM\MongoDB\Proxy\Resolver\ClassNameResolver;
  17. use Doctrine\ODM\MongoDB\Proxy\Resolver\LazyGhostProxyClassNameResolver;
  18. use Doctrine\ODM\MongoDB\Proxy\Resolver\ProxyManagerClassNameResolver;
  19. use Doctrine\ODM\MongoDB\Query\FilterCollection;
  20. use Doctrine\ODM\MongoDB\Repository\DocumentRepository;
  21. use Doctrine\ODM\MongoDB\Repository\GridFSRepository;
  22. use Doctrine\ODM\MongoDB\Repository\RepositoryFactory;
  23. use Doctrine\ODM\MongoDB\Repository\ViewRepository;
  24. use Doctrine\Persistence\Mapping\ProxyClassNameResolver;
  25. use Doctrine\Persistence\ObjectManager;
  26. use Doctrine\Persistence\ObjectRepository;
  27. use InvalidArgumentException;
  28. use Jean85\PrettyVersions;
  29. use MongoDB\Client;
  30. use MongoDB\Collection;
  31. use MongoDB\Database;
  32. use MongoDB\Driver\ReadPreference;
  33. use MongoDB\GridFS\Bucket;
  34. use ProxyManager\Proxy\GhostObjectInterface;
  35. use RuntimeException;
  36. use Throwable;
  38. use function array_search;
  39. use function assert;
  40. use function gettype;
  41. use function is_object;
  42. use function ltrim;
  43. use function sprintf;
  44. use function trigger_deprecation;
  46. /**
  47. * The DocumentManager class is the central access point for managing the
  48. * persistence of documents.
  49. *
  50. * <?php
  51. *
  52. * $config = new Configuration();
  53. * $dm = DocumentManager::create(new Connection(), $config);
  54. *
  55. * @phpstan-import-type CommitOptions from UnitOfWork
  56. * @phpstan-import-type FieldMapping from ClassMetadata
  57. */
  58. class DocumentManager implements ObjectManager
  59. {
  60. public const CLIENT_TYPEMAP = ['root' => 'array', 'document' => 'array'];
  62. /**
  63. * The Doctrine MongoDB connection instance.
  64. */
  65. private Client $client;
  67. /**
  68. * The used Configuration.
  69. */
  70. private Configuration $config;
  72. /**
  73. * The metadata factory, used to retrieve the ODM metadata of document classes.
  74. */
  75. private ClassMetadataFactoryInterface $metadataFactory;
  77. /**
  78. * The UnitOfWork used to coordinate object-level transactions.
  79. */
  80. private UnitOfWork $unitOfWork;
  82. /**
  83. * The event manager that is the central point of the event system.
  84. */
  85. private EventManager $eventManager;
  87. /**
  88. * The Hydrator factory instance.
  89. */
  90. private HydratorFactory $hydratorFactory;
  92. /**
  93. * The Proxy factory instance.
  94. */
  95. private ProxyFactory $proxyFactory;
  97. /**
  98. * The repository factory used to create dynamic repositories.
  99. */
  100. private RepositoryFactory $repositoryFactory;
  102. /**
  103. * SchemaManager instance
  104. */
  105. private SchemaManager $schemaManager;
  107. /**
  108. * Array of cached document database instances that are lazily loaded.
  109. *
  110. * @var Database[]
  111. */
  112. private array $documentDatabases = [];
  114. /**
  115. * Array of cached document collection instances that are lazily loaded.
  116. *
  117. * @var Collection[]
  118. */
  119. private array $documentCollections = [];
  121. /**
  122. * Array of cached document bucket instances that are lazily loaded.
  123. *
  124. * @var Bucket[]
  125. */
  126. private array $documentBuckets = [];
  128. /**
  129. * Whether the DocumentManager is closed or not.
  130. */
  131. private bool $closed = false;
  133. /**
  134. * Collection of query filters.
  135. */
  136. private ?FilterCollection $filterCollection = null;
  138. /** @var ProxyClassNameResolver&ClassNameResolver */
  139. private ProxyClassNameResolver $classNameResolver;
  141. private static ?string $version = null;
  143. /**
  144. * Creates a new Document that operates on the given Mongo connection
  145. * and uses the given Configuration.
  146. */
  147. protected function __construct(?Client $client = null, ?Configuration $config = null, ?EventManager $eventManager = null)
  148. {
  149. $this->config = $config ?: new Configuration();
  150. $this->eventManager = $eventManager ?: new EventManager();
  151. $this->client = $client ?: new Client(
  152. 'mongodb://127.0.0.1',
  153. [],
  154. [
  155. 'driver' => [
  156. 'name' => 'doctrine-odm',
  157. 'version' => self::getVersion(),
  158. ],
  159. ],
  160. );
  162. $this->classNameResolver = $this->config->isLazyGhostObjectEnabled()
  163. ? new CachingClassNameResolver(new LazyGhostProxyClassNameResolver())
  164. : new CachingClassNameResolver(new ProxyManagerClassNameResolver($this->config));
  166. $metadataFactoryClassName = $this->config->getClassMetadataFactoryName();
  167. $this->metadataFactory = new $metadataFactoryClassName();
  168. $this->metadataFactory->setDocumentManager($this);
  169. $this->metadataFactory->setConfiguration($this->config);
  170. $this->metadataFactory->setProxyClassNameResolver($this->classNameResolver);
  172. $cacheDriver = $this->config->getMetadataCache();
  173. if ($cacheDriver) {
  174. $this->metadataFactory->setCache($cacheDriver);
  175. }
  177. $hydratorDir = $this->config->getHydratorDir();
  178. $hydratorNs = $this->config->getHydratorNamespace();
  179. $this->hydratorFactory = new HydratorFactory(
  180. $this,
  181. $this->eventManager,
  182. $hydratorDir,
  183. $hydratorNs,
  184. $this->config->getAutoGenerateHydratorClasses(),
  185. );
  187. $this->unitOfWork = new UnitOfWork($this, $this->eventManager, $this->hydratorFactory);
  188. $this->schemaManager = new SchemaManager($this, $this->metadataFactory);
  189. $this->proxyFactory = $this->config->isLazyGhostObjectEnabled()
  190. ? new LazyGhostProxyFactory($this, $this->config->getProxyDir(), $this->config->getProxyNamespace(), $this->config->getAutoGenerateProxyClasses())
  191. : new StaticProxyFactory($this);
  192. $this->repositoryFactory = $this->config->getRepositoryFactory();
  193. }
  195. /**
  196. * Gets the proxy factory used by the DocumentManager to create document proxies.
  197. */
  198. public function getProxyFactory(): ProxyFactory
  199. {
  200. return $this->proxyFactory;
  201. }
  203. /**
  204. * Creates a new Document that operates on the given Mongo connection
  205. * and uses the given Configuration.
  206. */
  207. public static function create(?Client $client = null, ?Configuration $config = null, ?EventManager $eventManager = null): DocumentManager
  208. {
  209. return new static($client, $config, $eventManager);
  210. }
  212. /**
  213. * Gets the EventManager used by the DocumentManager.
  214. */
  215. public function getEventManager(): EventManager
  216. {
  217. return $this->eventManager;
  218. }
  220. /**
  221. * Gets the MongoDB client instance that this DocumentManager wraps.
  222. */
  223. public function getClient(): Client
  224. {
  225. return $this->client;
  226. }
  228. /** Gets the metadata factory used to gather the metadata of classes. */
  229. public function getMetadataFactory(): ClassmetadataFactoryInterface
  230. {
  231. return $this->metadataFactory;
  232. }
  234. /**
  235. * Helper method to initialize a lazy loading proxy or persistent collection.
  236. *
  237. * This method is a no-op for other objects.
  238. *
  239. * @param object $obj
  240. */
  241. public function initializeObject($obj): void
  242. {
  243. $this->unitOfWork->initializeObject($obj);
  244. }
  246. /**
  247. * Helper method to check whether a lazy loading proxy or persistent collection has been initialized.
  248. */
  249. public function isUninitializedObject(mixed $obj): bool
  250. {
  251. if (! is_object($obj)) {
  252. return false;
  253. }
  255. return $this->unitOfWork->isUninitializedObject($obj);
  256. }
  258. /**
  259. * Gets the UnitOfWork used by the DocumentManager to coordinate operations.
  260. */
  261. public function getUnitOfWork(): UnitOfWork
  262. {
  263. return $this->unitOfWork;
  264. }
  266. /**
  267. * Gets the Hydrator factory used by the DocumentManager to generate and get hydrators
  268. * for each type of document.
  269. */
  270. public function getHydratorFactory(): HydratorFactory
  271. {
  272. return $this->hydratorFactory;
  273. }
  275. /**
  276. * Returns SchemaManager, used to create/drop indexes/collections/databases.
  277. */
  278. public function getSchemaManager(): SchemaManager
  279. {
  280. return $this->schemaManager;
  281. }
  283. /**
  284. * Returns the class name resolver which is used to resolve real class names for proxy objects.
  285. *
  286. * @deprecated Fetch metadata for any class string (e.g. proxy object class) and read the class name from the metadata object
  287. */
  288. public function getClassNameResolver(): ClassNameResolver
  289. {
  290. return $this->classNameResolver;
  291. }
  293. /**
  294. * Returns the metadata for a class.
  295. *
  296. * @param class-string<T> $className The class name.
  297. *
  298. * @return ClassMetadata<T>
  299. *
  300. * @template T of object
  301. */
  302. public function getClassMetadata($className): ClassMetadata
  303. {
  304. return $this->metadataFactory->getMetadataFor($className);
  305. }
  307. /**
  308. * Returns the MongoDB instance for a class.
  309. *
  310. * @param class-string $className
  311. */
  312. public function getDocumentDatabase(string $className): Database
  313. {
  314. $metadata = $this->metadataFactory->getMetadataFor($className);
  316. $className = $metadata->getName();
  318. if (isset($this->documentDatabases[$className])) {
  319. return $this->documentDatabases[$className];
  320. }
  322. $db = $metadata->getDatabase();
  323. $db = $db ?: $this->config->getDefaultDB();
  324. $db = $db ?: 'doctrine';
  325. $this->documentDatabases[$className] = $this->client->getDatabase($db);
  327. return $this->documentDatabases[$className];
  328. }
  330. /**
  331. * Gets the array of instantiated document database instances.
  332. *
  333. * @return Database[]
  334. */
  335. public function getDocumentDatabases(): array
  336. {
  337. return $this->documentDatabases;
  338. }
  340. /**
  341. * Returns the collection instance for a class.
  342. *
  343. * @throws MongoDBException When the $className param is not mapped to a collection.
  344. */
  345. public function getDocumentCollection(string $className): Collection
  346. {
  347. $metadata = $this->metadataFactory->getMetadataFor($className);
  349. if ($metadata->isFile) {
  350. return $this->getDocumentBucket($className)->getFilesCollection();
  351. }
  353. $collectionName = $metadata->getCollection();
  355. if (! $collectionName) {
  356. throw MongoDBException::documentNotMappedToCollection($className);
  357. }
  359. if (! isset($this->documentCollections[$className])) {
  360. $db = $this->getDocumentDatabase($className);
  362. $options = ['typeMap' => self::CLIENT_TYPEMAP];
  363. if ($metadata->readPreference !== null) {
  364. $options['readPreference'] = new ReadPreference($metadata->readPreference, $metadata->readPreferenceTags);
  365. }
  367. $this->documentCollections[$className] = $db->getCollection($collectionName, $options);
  368. }
  370. return $this->documentCollections[$className];
  371. }
  373. /**
  374. * Returns the bucket instance for a class.
  375. *
  376. * @throws MongoDBException When the $className param is not mapped to a collection.
  377. */
  378. public function getDocumentBucket(string $className): Bucket
  379. {
  380. $metadata = $this->metadataFactory->getMetadataFor($className);
  382. if (! $metadata->isFile) {
  383. throw MongoDBException::documentBucketOnlyAvailableForGridFSFiles($className);
  384. }
  386. $bucketName = $metadata->getBucketName();
  388. if (! $bucketName) {
  389. throw MongoDBException::documentNotMappedToCollection($className);
  390. }
  392. if (! isset($this->documentBuckets[$className])) {
  393. $db = $this->getDocumentDatabase($className);
  395. $options = ['bucketName' => $bucketName, 'typeMap' => self::CLIENT_TYPEMAP];
  396. if ($metadata->readPreference !== null) {
  397. $options['readPreference'] = new ReadPreference($metadata->readPreference, $metadata->readPreferenceTags);
  398. }
  400. $this->documentBuckets[$className] = $db->selectGridFSBucket($options);
  401. }
  403. return $this->documentBuckets[$className];
  404. }
  406. /**
  407. * Gets the array of instantiated document collection instances.
  408. *
  409. * @return Collection[]
  410. */
  411. public function getDocumentCollections(): array
  412. {
  413. return $this->documentCollections;
  414. }
  416. /**
  417. * Create a new Query instance for a class.
  418. *
  419. * @param string[]|string|null $documentName (optional) an array of document names, the document name, or none
  420. */
  421. public function createQueryBuilder($documentName = null): Query\Builder
  422. {
  423. return new Query\Builder($this, $documentName);
  424. }
  426. /**
  427. * Creates a new aggregation builder instance for a class.
  428. */
  429. public function createAggregationBuilder(string $documentName): Aggregation\Builder
  430. {
  431. return new Aggregation\Builder($this, $documentName);
  432. }
  434. /**
  435. * Tells the DocumentManager to make an instance managed and persistent.
  436. *
  437. * The document will be entered into the database at or before transaction
  438. * commit or as a result of the flush operation.
  439. *
  440. * NOTE: The persist operation always considers documents that are not yet known to
  441. * this DocumentManager as NEW. Do not pass detached documents to the persist operation.
  442. *
  443. * @param object $object The instance to make managed and persistent.
  444. *
  445. * @throws InvalidArgumentException When the given $object param is not an object.
  446. */
  447. public function persist($object): void
  448. {
  449. if (! is_object($object)) {
  450. throw new InvalidArgumentException(gettype($object));
  451. }
  453. $this->errorIfClosed();
  454. $this->unitOfWork->persist($object);
  455. }
  457. /**
  458. * Removes a document instance.
  459. *
  460. * A removed document will be removed from the database at or before transaction commit
  461. * or as a result of the flush operation.
  462. *
  463. * @param object $object The document instance to remove.
  464. *
  465. * @throws InvalidArgumentException When the $object param is not an object.
  466. */
  467. public function remove($object): void
  468. {
  469. if (! is_object($object)) {
  470. throw new InvalidArgumentException(gettype($object));
  471. }
  473. $this->errorIfClosed();
  474. $this->unitOfWork->remove($object);
  475. }
  477. /**
  478. * Refreshes the persistent state of a document from the database,
  479. * overriding any local changes that have not yet been persisted.
  480. *
  481. * @param object $object The document to refresh.
  482. *
  483. * @throws InvalidArgumentException When the given $object param is not an object.
  484. */
  485. public function refresh($object): void
  486. {
  487. if (! is_object($object)) {
  488. throw new InvalidArgumentException(gettype($object));
  489. }
  491. $this->errorIfClosed();
  492. $this->unitOfWork->refresh($object);
  493. }
  495. /**
  496. * Detaches a document from the DocumentManager, causing a managed document to
  497. * become detached. Unflushed changes made to the document if any
  498. * (including removal of the document), will not be synchronized to the database.
  499. * Documents which previously referenced the detached document will continue to
  500. * reference it.
  501. *
  502. * @param object $object The document to detach.
  503. *
  504. * @throws InvalidArgumentException When the $object param is not an object.
  505. */
  506. public function detach($object): void
  507. {
  508. if (! is_object($object)) {
  509. throw new InvalidArgumentException(gettype($object));
  510. }
  512. $this->unitOfWork->detach($object);
  513. }
  515. /**
  516. * Merges the state of a detached document into the persistence context
  517. * of this DocumentManager and returns the managed copy of the document.
  518. * The document passed to merge will not become associated/managed with this DocumentManager.
  519. *
  520. * @param object $object The detached document to merge into the persistence context.
  521. *
  522. * @return object The managed copy of the document.
  523. *
  524. * @throws LockException
  525. * @throws InvalidArgumentException If the $object param is not an object.
  526. */
  527. public function merge($object)
  528. {
  529. if (! is_object($object)) {
  530. throw new InvalidArgumentException(gettype($object));
  531. }
  533. $this->errorIfClosed();
  535. return $this->unitOfWork->merge($object);
  536. }
  538. /**
  539. * Acquire a lock on the given document.
  540. *
  541. * @throws InvalidArgumentException
  542. * @throws LockException
  543. */
  544. public function lock(object $document, int $lockMode, ?int $lockVersion = null): void
  545. {
  546. $this->unitOfWork->lock($document, $lockMode, $lockVersion);
  547. }
  549. /**
  550. * Releases a lock on the given document.
  551. */
  552. public function unlock(object $document): void
  553. {
  554. $this->unitOfWork->unlock($document);
  555. }
  557. /**
  558. * Gets the repository for a document class.
  559. *
  560. * @param class-string<T> $className The name of the Document.
  561. *
  562. * @return DocumentRepository<T>|GridFSRepository<T>|ViewRepository<T> The repository.
  563. *
  564. * @template T of object
  565. */
  566. public function getRepository($className): ObjectRepository
  567. {
  568. return $this->repositoryFactory->getRepository($this, $className);
  569. }
  571. /**
  572. * Flushes all changes to objects that have been queued up to now to the database.
  573. * This effectively synchronizes the in-memory state of managed objects with the
  574. * database.
  575. *
  576. * @param array $options Array of options to be used with batchInsert(), update() and remove()
  577. * @phpstan-param CommitOptions $options
  578. *
  579. * @throws MongoDBException
  580. * @throws Throwable From event listeners.
  581. */
  582. public function flush(array $options = []): void
  583. {
  584. $this->errorIfClosed();
  585. $this->unitOfWork->commit($options);
  586. }
  588. /**
  589. * Gets a reference to the document identified by the given type and identifier
  590. * without actually loading it.
  591. *
  592. * If partial objects are allowed, this method will return a partial object that only
  593. * has its identifier populated. Otherwise a proxy is returned that automatically
  594. * loads itself on first access.
  595. *
  596. * @param mixed $identifier
  597. * @param class-string<T> $documentName
  598. *
  599. * @return T|(T&GhostObjectInterface<T>)
  600. *
  601. * @template T of object
  602. */
  603. public function getReference(string $documentName, $identifier): object
  604. {
  605. /** @var ClassMetadata<T> $class */
  606. $class = $this->metadataFactory->getMetadataFor(ltrim($documentName, '\\'));
  607. assert($class instanceof ClassMetadata);
  608. /** @phpstan-var T|false $document */
  609. $document = $this->unitOfWork->tryGetById($identifier, $class);
  611. // Check identity map first, if its already in there just return it.
  612. if ($document !== false) {
  613. return $document;
  614. }
  616. /** @var T&GhostObjectInterface<T> $document */
  617. $document = $this->proxyFactory->getProxy($class, $identifier);
  618. $this->unitOfWork->registerManaged($document, $identifier, []);
  620. return $document;
  621. }
  623. /**
  624. * Gets a partial reference to the document identified by the given type and identifier
  625. * without actually loading it, if the document is not yet loaded.
  626. *
  627. * The returned reference may be a partial object if the document is not yet loaded/managed.
  628. * If it is a partial object it will not initialize the rest of the document state on access.
  629. * Thus you can only ever safely access the identifier of a document obtained through
  630. * this method.
  631. *
  632. * The use-cases for partial references involve maintaining bidirectional associations
  633. * without loading one side of the association or to update a document without loading it.
  634. * Note, however, that in the latter case the original (persistent) document data will
  635. * never be visible to the application (especially not event listeners) as it will
  636. * never be loaded in the first place.
  637. *
  638. * @param mixed $identifier The document identifier.
  639. */
  640. public function getPartialReference(string $documentName, $identifier): object
  641. {
  642. $class = $this->metadataFactory->getMetadataFor(ltrim($documentName, '\\'));
  644. $document = $this->unitOfWork->tryGetById($identifier, $class);
  646. // Check identity map first, if its already in there just return it.
  647. if ($document) {
  648. return $document;
  649. }
  651. $document = $class->newInstance();
  652. $class->setIdentifierValue($document, $identifier);
  653. $this->unitOfWork->registerManaged($document, $identifier, []);
  655. return $document;
  656. }
  658. /**
  659. * Finds a Document by its identifier.
  660. *
  661. * This is just a convenient shortcut for getRepository($documentName)->find($id).
  662. *
  663. * @param class-string<T> $className
  664. * @param mixed $id
  665. * @param int $lockMode
  666. * @param int $lockVersion
  667. *
  668. * @return T|null
  669. *
  670. * @template T of object
  671. */
  672. public function find($className, $id, $lockMode = LockMode::NONE, $lockVersion = null): ?object
  673. {
  674. $repository = $this->getRepository($className);
  675. if ($repository instanceof DocumentRepository) {
  676. return $repository->find($id, $lockMode, $lockVersion);
  677. }
  679. return $repository->find($id);
  680. }
  682. /**
  683. * Clears the DocumentManager.
  684. *
  685. * All documents that are currently managed by this DocumentManager become
  686. * detached.
  687. *
  688. * @param string|null $objectName if given, only documents of this type will get detached
  689. */
  690. public function clear($objectName = null): void
  691. {
  692. if ($objectName !== null) {
  693. trigger_deprecation(
  694. 'doctrine/mongodb-odm',
  695. '2.4',
  696. 'Calling %s() with any arguments to clear specific documents is deprecated and will not be supported in Doctrine ODM 3.0.',
  697. __METHOD__,
  698. );
  699. }
  701. $this->unitOfWork->clear($objectName);
  702. }
  704. /**
  705. * Closes the DocumentManager. All documents that are currently managed
  706. * by this DocumentManager become detached. The DocumentManager may no longer
  707. * be used after it is closed.
  708. *
  709. * @return void
  710. */
  711. public function close()
  712. {
  713. $this->clear();
  714. $this->closed = true;
  715. }
  717. /**
  718. * Determines whether a document instance is managed in this DocumentManager.
  719. *
  720. * @param object $object
  721. *
  722. * @return bool TRUE if this DocumentManager currently manages the given document, FALSE otherwise.
  723. *
  724. * @throws InvalidArgumentException When the $object param is not an object.
  725. */
  726. public function contains($object): bool
  727. {
  728. if (! is_object($object)) {
  729. throw new InvalidArgumentException(gettype($object));
  730. }
  732. return $this->unitOfWork->isScheduledForInsert($object) ||
  733. $this->unitOfWork->isInIdentityMap($object) &&
  734. ! $this->unitOfWork->isScheduledForDelete($object);
  735. }
  737. /**
  738. * Gets the Configuration used by the DocumentManager.
  739. */
  740. public function getConfiguration(): Configuration
  741. {
  742. return $this->config;
  743. }
  745. /**
  746. * Returns a reference to the supplied document.
  747. *
  748. * @phpstan-param FieldMapping $referenceMapping
  749. *
  750. * @return mixed The reference for the document in question, according to the desired mapping
  751. *
  752. * @throws MappingException
  753. * @throws RuntimeException
  754. */
  755. public function createReference(object $document, array $referenceMapping)
  756. {
  757. $class = $this->getClassMetadata($document::class);
  758. $id = $this->unitOfWork->getDocumentIdentifier($document);
  760. if ($id === null) {
  761. throw new RuntimeException(
  762. sprintf('Cannot create a DBRef for class %s without an identifier. Have you forgotten to persist/merge the document first?', $class->name),
  763. );
  764. }
  766. $storeAs = $referenceMapping['storeAs'] ?? null;
  767. switch ($storeAs) {
  768. case ClassMetadata::REFERENCE_STORE_AS_ID:
  769. if ($class->inheritanceType === ClassMetadata::INHERITANCE_TYPE_SINGLE_COLLECTION) {
  770. throw MappingException::simpleReferenceMustNotTargetDiscriminatedDocument($referenceMapping['targetDocument']);
  771. }
  773. return $class->getDatabaseIdentifierValue($id);
  775. case ClassMetadata::REFERENCE_STORE_AS_REF:
  776. $reference = ['id' => $class->getDatabaseIdentifierValue($id)];
  777. break;
  779. case ClassMetadata::REFERENCE_STORE_AS_DB_REF:
  780. $reference = [
  781. '$ref' => $class->getCollection(),
  782. '$id' => $class->getDatabaseIdentifierValue($id),
  783. ];
  784. break;
  786. case ClassMetadata::REFERENCE_STORE_AS_DB_REF_WITH_DB:
  787. $reference = [
  788. '$ref' => $class->getCollection(),
  789. '$id' => $class->getDatabaseIdentifierValue($id),
  790. '$db' => $this->getDocumentDatabase($class->name)->getDatabaseName(),
  791. ];
  792. break;
  794. default:
  795. throw new InvalidArgumentException(sprintf('Reference type %s is invalid.', $storeAs));
  796. }
  798. return $reference + $this->getDiscriminatorData($referenceMapping, $class);
  799. }
  801. /**
  802. * Build discriminator portion of reference for specified reference mapping and class metadata.
  803. *
  804. * @param array $referenceMapping Mappings of reference for which discriminator data is created.
  805. * @param ClassMetadata<object> $class Metadata of reference document class.
  806. * @phpstan-param FieldMapping $referenceMapping
  807. *
  808. * @return array<string, class-string> with next structure [{discriminator field} => {discriminator value}]
  809. *
  810. * @throws MappingException When discriminator map is present and reference class in not registered in it.
  811. */
  812. private function getDiscriminatorData(array $referenceMapping, ClassMetadata $class): array
  813. {
  814. $discriminatorField = null;
  815. $discriminatorValue = null;
  816. $discriminatorMap = null;
  818. if (isset($referenceMapping['discriminatorField'])) {
  819. $discriminatorField = $referenceMapping['discriminatorField'];
  821. if (isset($referenceMapping['discriminatorMap'])) {
  822. $discriminatorMap = $referenceMapping['discriminatorMap'];
  823. }
  824. } else {
  825. $discriminatorField = $class->discriminatorField;
  826. $discriminatorValue = $class->discriminatorValue;
  827. $discriminatorMap = $class->discriminatorMap;
  828. }
  830. if ($discriminatorField === null) {
  831. return [];
  832. }
  834. if ($discriminatorValue === null) {
  835. if (! empty($discriminatorMap)) {
  836. $pos = array_search($class->name, $discriminatorMap);
  838. if ($pos !== false) {
  839. $discriminatorValue = $pos;
  840. }
  841. } else {
  842. $discriminatorValue = $class->name;
  843. }
  844. }
  846. if ($discriminatorValue === null) {
  847. throw MappingException::unlistedClassInDiscriminatorMap($class->name);
  848. }
  850. return [$discriminatorField => $discriminatorValue];
  851. }
  853. /**
  854. * Throws an exception if the DocumentManager is closed or currently not active.
  855. *
  856. * @throws MongoDBException If the DocumentManager is closed.
  857. */
  858. private function errorIfClosed(): void
  859. {
  860. if ($this->closed) {
  861. throw MongoDBException::documentManagerClosed();
  862. }
  863. }
  865. /**
  866. * Check if the Document manager is open or closed.
  867. */
  868. public function isOpen(): bool
  869. {
  870. return ! $this->closed;
  871. }
  873. /**
  874. * Gets the filter collection.
  875. */
  876. public function getFilterCollection(): FilterCollection
  877. {
  878. if ($this->filterCollection === null) {
  879. $this->filterCollection = new FilterCollection($this);
  880. }
  882. return $this->filterCollection;
  883. }
  885. /**
  886. * Gets the class name for an association (embed or reference) with respect
  887. * to any discriminator value.
  888. *
  889. * @internal
  890. *
  891. * @param FieldMapping $mapping
  892. * @param array<string, mixed>|null $data
  893. *
  894. * @return class-string
  895. */
  896. public function getClassNameForAssociation(array $mapping, $data): string
  897. {
  898. $discriminatorField = $mapping['discriminatorField'] ?? null;
  900. $discriminatorValue = null;
  901. if (isset($discriminatorField, $data[$discriminatorField])) {
  902. $discriminatorValue = $data[$discriminatorField];
  903. } elseif (isset($mapping['defaultDiscriminatorValue'])) {
  904. $discriminatorValue = $mapping['defaultDiscriminatorValue'];
  905. }
  907. if ($discriminatorValue !== null) {
  908. return $mapping['discriminatorMap'][$discriminatorValue]
  909. ?? (string) $discriminatorValue;
  910. }
  912. $class = $this->getClassMetadata($mapping['targetDocument']);
  914. if (isset($class->discriminatorField, $data[$class->discriminatorField])) {
  915. $discriminatorValue = $data[$class->discriminatorField];
  916. } elseif ($class->defaultDiscriminatorValue !== null) {
  917. $discriminatorValue = $class->defaultDiscriminatorValue;
  918. }
  920. if ($discriminatorValue !== null) {
  921. return $class->discriminatorMap[$discriminatorValue] ?? $discriminatorValue;
  922. }
  924. return $mapping['targetDocument'];
  925. }
  927. private static function getVersion(): string
  928. {
  929. if (self::$version === null) {
  930. try {
  931. self::$version = PrettyVersions::getVersion('doctrine/mongodb-odm')->getPrettyVersion();
  932. } catch (Throwable) {
  933. return 'unknown';
  934. }
  935. }
  937. return self::$version;
  938. }
  939. }