vendor/doctrine/orm/src/Mapping/ClassMetadataFactory.php line 345

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Mapping;
  7. use Doctrine\Common\EventManager;
  8. use Doctrine\DBAL\Platforms;
  9. use Doctrine\DBAL\Platforms\AbstractPlatform;
  10. use Doctrine\DBAL\Platforms\MySQLPlatform;
  11. use Doctrine\DBAL\Platforms\SqlitePlatform;
  12. use Doctrine\DBAL\Platforms\SQLServerPlatform;
  13. use Doctrine\Deprecations\Deprecation;
  14. use Doctrine\ORM\EntityManagerInterface;
  15. use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
  16. use Doctrine\ORM\Event\OnClassMetadataNotFoundEventArgs;
  17. use Doctrine\ORM\Events;
  18. use Doctrine\ORM\Exception\ORMException;
  19. use Doctrine\ORM\Id\AssignedGenerator;
  20. use Doctrine\ORM\Id\BigIntegerIdentityGenerator;
  21. use Doctrine\ORM\Id\IdentityGenerator;
  22. use Doctrine\ORM\Id\SequenceGenerator;
  23. use Doctrine\ORM\Id\UuidGenerator;
  24. use Doctrine\ORM\Mapping\Exception\CannotGenerateIds;
  25. use Doctrine\ORM\Mapping\Exception\InvalidCustomGenerator;
  26. use Doctrine\ORM\Mapping\Exception\UnknownGeneratorType;
  27. use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
  28. use Doctrine\Persistence\Mapping\AbstractClassMetadataFactory;
  29. use Doctrine\Persistence\Mapping\ClassMetadata as ClassMetadataInterface;
  30. use Doctrine\Persistence\Mapping\Driver\MappingDriver;
  31. use Doctrine\Persistence\Mapping\ReflectionService;
  32. use ReflectionClass;
  33. use ReflectionException;
  35. use function assert;
  36. use function class_exists;
  37. use function count;
  38. use function end;
  39. use function explode;
  40. use function get_class;
  41. use function in_array;
  42. use function is_a;
  43. use function is_subclass_of;
  44. use function str_contains;
  45. use function strlen;
  46. use function strtolower;
  47. use function substr;
  49. /**
  50.  * The ClassMetadataFactory is used to create ClassMetadata objects that contain all the
  51.  * metadata mapping information of a class which describes how a class should be mapped
  52.  * to a relational database.
  53.  *
  54.  * @extends AbstractClassMetadataFactory<ClassMetadata>
  55.  * @psalm-import-type AssociationMapping from ClassMetadata
  56.  * @psalm-import-type EmbeddedClassMapping from ClassMetadata
  57.  * @psalm-import-type FieldMapping from ClassMetadata
  58.  */
  59. class ClassMetadataFactory extends AbstractClassMetadataFactory
  60. {
  61.     /** @var EntityManagerInterface|null */
  62.     private $em;
  64.     /** @var AbstractPlatform|null */
  65.     private $targetPlatform;
  67.     /** @var MappingDriver */
  68.     private $driver;
  70.     /** @var EventManager */
  71.     private $evm;
  73.     /** @var mixed[] */
  74.     private $embeddablesActiveNesting = [];
  76.     private const NON_IDENTITY_DEFAULT_STRATEGY = [
  77.         'Doctrine\DBAL\Platforms\PostgreSqlPlatform' => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
  78.         Platforms\OraclePlatform::class => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
  79.         Platforms\PostgreSQLPlatform::class => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
  80.     ];
  82.     /** @return void */
  83.     public function setEntityManager(EntityManagerInterface $em)
  84.     {
  85.         parent::setProxyClassNameResolver(new DefaultProxyClassNameResolver());
  87.         $this->em = $em;
  88.     }
  90.     /**
  91.      * {@inheritDoc}
  92.      */
  93.     protected function initialize()
  94.     {
  95.         $this->driver      = $this->em->getConfiguration()->getMetadataDriverImpl();
  96.         $this->evm         = $this->em->getEventManager();
  97.         $this->initialized = true;
  98.     }
  100.     /**
  101.      * {@inheritDoc}
  102.      */
  103.     protected function onNotFoundMetadata($className)
  104.     {
  105.         if (! $this->evm->hasListeners(Events::onClassMetadataNotFound)) {
  106.             return null;
  107.         }
  109.         $eventArgs = new OnClassMetadataNotFoundEventArgs($className, $this->em);
  111.         $this->evm->dispatchEvent(Events::onClassMetadataNotFound, $eventArgs);
  112.         $classMetadata = $eventArgs->getFoundMetadata();
  113.         assert($classMetadata instanceof ClassMetadata || $classMetadata === null);
  115.         return $classMetadata;
  116.     }
  118.     /**
  119.      * {@inheritDoc}
  120.      */
  121.     protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
  122.     {
  123.         if ($parent) {
  124.             $class->setInheritanceType($parent->inheritanceType);
  125.             $class->setDiscriminatorColumn($parent->discriminatorColumn);
  126.             $class->setIdGeneratorType($parent->generatorType);
  127.             $this->addInheritedFields($class, $parent);
  128.             $this->addInheritedRelations($class, $parent);
  129.             $this->addInheritedEmbeddedClasses($class, $parent);
  130.             $class->setIdentifier($parent->identifier);
  131.             $class->setVersioned($parent->isVersioned);
  132.             $class->setVersionField($parent->versionField);
  133.             $class->setDiscriminatorMap($parent->discriminatorMap);
  134.             $class->addSubClasses($parent->subClasses);
  135.             $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
  136.             $class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
  138.             if (! empty($parent->customGeneratorDefinition)) {
  139.                 $class->setCustomGeneratorDefinition($parent->customGeneratorDefinition);
  140.             }
  142.             if ($parent->isMappedSuperclass) {
  143.                 $class->setCustomRepositoryClass($parent->customRepositoryClassName);
  144.             }
  145.         }
  147.         // Invoke driver
  148.         try {
  149.             $this->driver->loadMetadataForClass($class->getName(), $class);
  150.         } catch (ReflectionException $e) {
  151.             throw MappingException::reflectionFailure($class->getName(), $e);
  152.         }
  154.         // If this class has a parent the id generator strategy is inherited.
  155.         // However this is only true if the hierarchy of parents contains the root entity,
  156.         // if it consists of mapped superclasses these don't necessarily include the id field.
  157.         if ($parent && $rootEntityFound) {
  158.             $this->inheritIdGeneratorMapping($class, $parent);
  159.         } else {
  160.             $this->completeIdGeneratorMapping($class);
  161.         }
  163.         if (! $class->isMappedSuperclass) {
  164.             if ($rootEntityFound && $class->isInheritanceTypeNone()) {
  165.                 Deprecation::trigger(
  166.                     'doctrine/orm',
  167.                     'https://github.com/doctrine/orm/pull/10431',
  168.                     "Entity class '%s' is a subclass of the root entity class '%s', but no inheritance mapping type was declared. This is a misconfiguration and will be an error in Doctrine ORM 3.0.",
  169.                     $class->name,
  170.                     end($nonSuperclassParents)
  171.                 );
  172.             }
  174.             foreach ($class->embeddedClasses as $property => $embeddableClass) {
  175.                 if (isset($embeddableClass['inherited'])) {
  176.                     continue;
  177.                 }
  179.                 if (isset($this->embeddablesActiveNesting[$embeddableClass['class']])) {
  180.                     throw MappingException::infiniteEmbeddableNesting($class->name, $property);
  181.                 }
  183.                 $this->embeddablesActiveNesting[$class->name] = true;
  185.                 $embeddableMetadata = $this->getMetadataFor($embeddableClass['class']);
  187.                 if ($embeddableMetadata->isEmbeddedClass) {
  188.                     $this->addNestedEmbeddedClasses($embeddableMetadata, $class, $property);
  189.                 }
  191.                 $identifier = $embeddableMetadata->getIdentifier();
  193.                 if (! empty($identifier)) {
  194.                     $this->inheritIdGeneratorMapping($class, $embeddableMetadata);
  195.                 }
  197.                 $class->inlineEmbeddable($property, $embeddableMetadata);
  199.                 unset($this->embeddablesActiveNesting[$class->name]);
  200.             }
  201.         }
  203.         if ($parent) {
  204.             if ($parent->isInheritanceTypeSingleTable()) {
  205.                 $class->setPrimaryTable($parent->table);
  206.             }
  208.             $this->addInheritedIndexes($class, $parent);
  210.             if ($parent->cache) {
  211.                 $class->cache = $parent->cache;
  212.             }
  214.             if ($parent->containsForeignIdentifier) {
  215.                 $class->containsForeignIdentifier = true;
  216.             }
  218.             if ($parent->containsEnumIdentifier) {
  219.                 $class->containsEnumIdentifier = true;
  220.             }
  222.             if (! empty($parent->namedQueries)) {
  223.                 $this->addInheritedNamedQueries($class, $parent);
  224.             }
  226.             if (! empty($parent->namedNativeQueries)) {
  227.                 $this->addInheritedNamedNativeQueries($class, $parent);
  228.             }
  230.             if (! empty($parent->sqlResultSetMappings)) {
  231.                 $this->addInheritedSqlResultSetMappings($class, $parent);
  232.             }
  234.             if (! empty($parent->entityListeners) && empty($class->entityListeners)) {
  235.                 $class->entityListeners = $parent->entityListeners;
  236.             }
  237.         }
  239.         $class->setParentClasses($nonSuperclassParents);
  241.         if ($class->isRootEntity() && ! $class->isInheritanceTypeNone() && ! $class->discriminatorMap) {
  242.             $this->addDefaultDiscriminatorMap($class);
  243.         }
  245.         // During the following event, there may also be updates to the discriminator map as per GH-1257/GH-8402.
  246.         // So, we must not discover the missing subclasses before that.
  248.         if ($this->evm->hasListeners(Events::loadClassMetadata)) {
  249.             $eventArgs = new LoadClassMetadataEventArgs($class, $this->em);
  250.             $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
  251.         }
  253.         $this->findAbstractEntityClassesNotListedInDiscriminatorMap($class);
  255.         if ($class->changeTrackingPolicy === ClassMetadata::CHANGETRACKING_NOTIFY) {
  256.             Deprecation::trigger(
  257.                 'doctrine/orm',
  258.                 'https://github.com/doctrine/orm/issues/8383',
  259.                 'NOTIFY Change Tracking policy used in "%s" is deprecated, use deferred explicit instead.',
  260.                 $class->name
  261.             );
  262.         }
  264.         $this->validateRuntimeMetadata($class, $parent);
  265.     }
  267.     /**
  268.      * Validate runtime metadata is correctly defined.
  269.      *
  270.      * @param ClassMetadata               $class
  271.      * @param ClassMetadataInterface|null $parent
  272.      *
  273.      * @return void
  274.      *
  275.      * @throws MappingException
  276.      */
  277.     protected function validateRuntimeMetadata($class, $parent)
  278.     {
  279.         if (! $class->reflClass) {
  280.             // only validate if there is a reflection class instance
  281.             return;
  282.         }
  284.         $class->validateIdentifier();
  285.         $class->validateAssociations();
  286.         $class->validateLifecycleCallbacks($this->getReflectionService());
  288.         // verify inheritance
  289.         if (! $class->isMappedSuperclass && ! $class->isInheritanceTypeNone()) {
  290.             if (! $parent) {
  291.                 if (count($class->discriminatorMap) === 0) {
  292.                     throw MappingException::missingDiscriminatorMap($class->name);
  293.                 }
  295.                 if (! $class->discriminatorColumn) {
  296.                     throw MappingException::missingDiscriminatorColumn($class->name);
  297.                 }
  299.                 foreach ($class->subClasses as $subClass) {
  300.                     if ((new ReflectionClass($subClass))->name !== $subClass) {
  301.                         throw MappingException::invalidClassInDiscriminatorMap($subClass, $class->name);
  302.                     }
  303.                 }
  304.             } else {
  305.                 assert($parent instanceof ClassMetadataInfo); // https://github.com/doctrine/orm/issues/8746
  306.                 if (
  307.                     ! $class->reflClass->isAbstract()
  308.                     && ! in_array($class->name, $class->discriminatorMap, true)
  309.                 ) {
  310.                     throw MappingException::mappedClassNotPartOfDiscriminatorMap($class->name, $class->rootEntityName);
  311.                 }
  312.             }
  313.         } elseif ($class->isMappedSuperclass && $class->name === $class->rootEntityName && (count($class->discriminatorMap) || $class->discriminatorColumn)) {
  314.             // second condition is necessary for mapped superclasses in the middle of an inheritance hierarchy
  315.             throw MappingException::noInheritanceOnMappedSuperClass($class->name);
  316.         }
  317.     }
  319.     /**
  320.      * {@inheritDoc}
  321.      */
  322.     protected function newClassMetadataInstance($className)
  323.     {
  324.         return new ClassMetadata(
  325.             $className,
  326.             $this->em->getConfiguration()->getNamingStrategy(),
  327.             $this->em->getConfiguration()->getTypedFieldMapper()
  328.         );
  329.     }
  331.     /**
  332.      * Adds a default discriminator map if no one is given
  333.      *
  334.      * If an entity is of any inheritance type and does not contain a
  335.      * discriminator map, then the map is generated automatically. This process
  336.      * is expensive computation wise.
  337.      *
  338.      * The automatically generated discriminator map contains the lowercase short name of
  339.      * each class as key.
  340.      *
  341.      * @throws MappingException
  342.      */
  343.     private function addDefaultDiscriminatorMap(ClassMetadata $class): void
  344.     {
  345.         $allClasses = $this->driver->getAllClassNames();
  346.         $fqcn       = $class->getName();
  347.         $map        = [$this->getShortName($class->name) => $fqcn];
  349.         $duplicates = [];
  350.         foreach ($allClasses as $subClassCandidate) {
  351.             if (is_subclass_of($subClassCandidate, $fqcn)) {
  352.                 $shortName = $this->getShortName($subClassCandidate);
  354.                 if (isset($map[$shortName])) {
  355.                     $duplicates[] = $shortName;
  356.                 }
  358.                 $map[$shortName] = $subClassCandidate;
  359.             }
  360.         }
  362.         if ($duplicates) {
  363.             throw MappingException::duplicateDiscriminatorEntry($class->name, $duplicates, $map);
  364.         }
  366.         $class->setDiscriminatorMap($map);
  367.     }
  369.     private function findAbstractEntityClassesNotListedInDiscriminatorMap(ClassMetadata $rootEntityClass): void
  370.     {
  371.         // Only root classes in inheritance hierarchies need contain a discriminator map,
  372.         // so skip for other classes.
  373.         if (! $rootEntityClass->isRootEntity() || $rootEntityClass->isInheritanceTypeNone()) {
  374.             return;
  375.         }
  377.         $processedClasses = [$rootEntityClass->name => true];
  378.         foreach ($rootEntityClass->subClasses as $knownSubClass) {
  379.             $processedClasses[$knownSubClass] = true;
  380.         }
  382.         foreach ($rootEntityClass->discriminatorMap as $declaredClassName) {
  383.             // This fetches non-transient parent classes only
  384.             $parentClasses = $this->getParentClasses($declaredClassName);
  386.             foreach ($parentClasses as $parentClass) {
  387.                 if (isset($processedClasses[$parentClass])) {
  388.                     continue;
  389.                 }
  391.                 $processedClasses[$parentClass] = true;
  393.                 // All non-abstract entity classes must be listed in the discriminator map, and
  394.                 // this will be validated/enforced at runtime (possibly at a later time, when the
  395.                 // subclass is loaded, but anyways). Also, subclasses is about entity classes only.
  396.                 // That means we can ignore non-abstract classes here. The (expensive) driver
  397.                 // check for mapped superclasses need only be run for abstract candidate classes.
  398.                 if (! (new ReflectionClass($parentClass))->isAbstract() || $this->peekIfIsMappedSuperclass($parentClass)) {
  399.                     continue;
  400.                 }
  402.                 // We have found a non-transient, non-mapped-superclass = an entity class (possibly abstract, but that does not matter)
  403.                 $rootEntityClass->addSubClass($parentClass);
  404.             }
  405.         }
  406.     }
  408.     /** @param class-string $className */
  409.     private function peekIfIsMappedSuperclass(string $className): bool
  410.     {
  411.         $reflService = $this->getReflectionService();
  412.         $class       = $this->newClassMetadataInstance($className);
  413.         $this->initializeReflection($class, $reflService);
  415.         $this->driver->loadMetadataForClass($className, $class);
  417.         return $class->isMappedSuperclass;
  418.     }
  420.     /**
  421.      * Gets the lower-case short name of a class.
  422.      *
  423.      * @psalm-param class-string $className
  424.      */
  425.     private function getShortName(string $className): string
  426.     {
  427.         if (! str_contains($className, '\\')) {
  428.             return strtolower($className);
  429.         }
  431.         $parts = explode('\\', $className);
  433.         return strtolower(end($parts));
  434.     }
  436.     /**
  437.      * Puts the `inherited` and `declared` values into mapping information for fields, associations
  438.      * and embedded classes.
  439.      *
  440.      * @param AssociationMapping|EmbeddedClassMapping|FieldMapping $mapping
  441.      */
  442.     private function addMappingInheritanceInformation(array &$mapping, ClassMetadata $parentClass): void
  443.     {
  444.         if (! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {
  445.             $mapping['inherited'] = $parentClass->name;
  446.         }
  448.         if (! isset($mapping['declared'])) {
  449.             $mapping['declared'] = $parentClass->name;
  450.         }
  451.     }
  453.     /**
  454.      * Adds inherited fields to the subclass mapping.
  455.      */
  456.     private function addInheritedFields(ClassMetadata $subClass, ClassMetadata $parentClass): void
  457.     {
  458.         foreach ($parentClass->fieldMappings as $mapping) {
  459.             $this->addMappingInheritanceInformation($mapping, $parentClass);
  460.             $subClass->addInheritedFieldMapping($mapping);
  461.         }
  463.         foreach ($parentClass->reflFields as $name => $field) {
  464.             $subClass->reflFields[$name] = $field;
  465.         }
  466.     }
  468.     /**
  469.      * Adds inherited association mappings to the subclass mapping.
  470.      *
  471.      * @throws MappingException
  472.      */
  473.     private function addInheritedRelations(ClassMetadata $subClass, ClassMetadata $parentClass): void
  474.     {
  475.         foreach ($parentClass->associationMappings as $field => $mapping) {
  476.             $this->addMappingInheritanceInformation($mapping, $parentClass);
  477.             // When the class inheriting the relation ($subClass) is the first entity class since the
  478.             // relation has been defined in a mapped superclass (or in a chain
  479.             // of mapped superclasses) above, then declare this current entity class as the source of
  480.             // the relationship.
  481.             // According to the definitions given in https://github.com/doctrine/orm/pull/10396/,
  482.             // this is the case <=> ! isset($mapping['inherited']).
  483.             if (! isset($mapping['inherited'])) {
  484.                 $mapping['sourceEntity'] = $subClass->name;
  485.             }
  487.             $subClass->addInheritedAssociationMapping($mapping);
  488.         }
  489.     }
  491.     private function addInheritedEmbeddedClasses(ClassMetadata $subClass, ClassMetadata $parentClass): void
  492.     {
  493.         foreach ($parentClass->embeddedClasses as $field => $embeddedClass) {
  494.             $this->addMappingInheritanceInformation($embeddedClass, $parentClass);
  495.             $subClass->embeddedClasses[$field] = $embeddedClass;
  496.         }
  497.     }
  499.     /**
  500.      * Adds nested embedded classes metadata to a parent class.
  501.      *
  502.      * @param ClassMetadata $subClass    Sub embedded class metadata to add nested embedded classes metadata from.
  503.      * @param ClassMetadata $parentClass Parent class to add nested embedded classes metadata to.
  504.      * @param string        $prefix      Embedded classes' prefix to use for nested embedded classes field names.
  505.      */
  506.     private function addNestedEmbeddedClasses(
  507.         ClassMetadata $subClass,
  508.         ClassMetadata $parentClass,
  509.         string $prefix
  510.     ): void {
  511.         foreach ($subClass->embeddedClasses as $property => $embeddableClass) {
  512.             if (isset($embeddableClass['inherited'])) {
  513.                 continue;
  514.             }
  516.             $embeddableMetadata = $this->getMetadataFor($embeddableClass['class']);
  518.             $parentClass->mapEmbedded(
  519.                 [
  520.                     'fieldName' => $prefix . '.' . $property,
  521.                     'class' => $embeddableMetadata->name,
  522.                     'columnPrefix' => $embeddableClass['columnPrefix'],
  523.                     'declaredField' => $embeddableClass['declaredField']
  524.                             ? $prefix . '.' . $embeddableClass['declaredField']
  525.                             : $prefix,
  526.                     'originalField' => $embeddableClass['originalField'] ?: $property,
  527.                 ]
  528.             );
  529.         }
  530.     }
  532.     /**
  533.      * Copy the table indices from the parent class superclass to the child class
  534.      */
  535.     private function addInheritedIndexes(ClassMetadata $subClass, ClassMetadata $parentClass): void
  536.     {
  537.         if (! $parentClass->isMappedSuperclass) {
  538.             return;
  539.         }
  541.         foreach (['uniqueConstraints', 'indexes'] as $indexType) {
  542.             if (isset($parentClass->table[$indexType])) {
  543.                 foreach ($parentClass->table[$indexType] as $indexName => $index) {
  544.                     if (isset($subClass->table[$indexType][$indexName])) {
  545.                         continue; // Let the inheriting table override indices
  546.                     }
  548.                     $subClass->table[$indexType][$indexName] = $index;
  549.                 }
  550.             }
  551.         }
  552.     }
  554.     /**
  555.      * Adds inherited named queries to the subclass mapping.
  556.      */
  557.     private function addInheritedNamedQueries(ClassMetadata $subClass, ClassMetadata $parentClass): void
  558.     {
  559.         foreach ($parentClass->namedQueries as $name => $query) {
  560.             if (! isset($subClass->namedQueries[$name])) {
  561.                 $subClass->addNamedQuery(
  562.                     [
  563.                         'name'  => $query['name'],
  564.                         'query' => $query['query'],
  565.                     ]
  566.                 );
  567.             }
  568.         }
  569.     }
  571.     /**
  572.      * Adds inherited named native queries to the subclass mapping.
  573.      */
  574.     private function addInheritedNamedNativeQueries(ClassMetadata $subClass, ClassMetadata $parentClass): void
  575.     {
  576.         foreach ($parentClass->namedNativeQueries as $name => $query) {
  577.             if (! isset($subClass->namedNativeQueries[$name])) {
  578.                 $subClass->addNamedNativeQuery(
  579.                     [
  580.                         'name'              => $query['name'],
  581.                         'query'             => $query['query'],
  582.                         'isSelfClass'       => $query['isSelfClass'],
  583.                         'resultSetMapping'  => $query['resultSetMapping'],
  584.                         'resultClass'       => $query['isSelfClass'] ? $subClass->name : $query['resultClass'],
  585.                     ]
  586.                 );
  587.             }
  588.         }
  589.     }
  591.     /**
  592.      * Adds inherited sql result set mappings to the subclass mapping.
  593.      */
  594.     private function addInheritedSqlResultSetMappings(ClassMetadata $subClass, ClassMetadata $parentClass): void
  595.     {
  596.         foreach ($parentClass->sqlResultSetMappings as $name => $mapping) {
  597.             if (! isset($subClass->sqlResultSetMappings[$name])) {
  598.                 $entities = [];
  599.                 foreach ($mapping['entities'] as $entity) {
  600.                     $entities[] = [
  601.                         'fields'                => $entity['fields'],
  602.                         'isSelfClass'           => $entity['isSelfClass'],
  603.                         'discriminatorColumn'   => $entity['discriminatorColumn'],
  604.                         'entityClass'           => $entity['isSelfClass'] ? $subClass->name : $entity['entityClass'],
  605.                     ];
  606.                 }
  608.                 $subClass->addSqlResultSetMapping(
  609.                     [
  610.                         'name'          => $mapping['name'],
  611.                         'columns'       => $mapping['columns'],
  612.                         'entities'      => $entities,
  613.                     ]
  614.                 );
  615.             }
  616.         }
  617.     }
  619.     /**
  620.      * Completes the ID generator mapping. If "auto" is specified we choose the generator
  621.      * most appropriate for the targeted database platform.
  622.      *
  623.      * @throws ORMException
  624.      */
  625.     private function completeIdGeneratorMapping(ClassMetadataInfo $class): void
  626.     {
  627.         $idGenType = $class->generatorType;
  628.         if ($idGenType === ClassMetadata::GENERATOR_TYPE_AUTO) {
  629.             $class->setIdGeneratorType($this->determineIdGeneratorStrategy($this->getTargetPlatform()));
  630.         }
  632.         // Create & assign an appropriate ID generator instance
  633.         switch ($class->generatorType) {
  634.             case ClassMetadata::GENERATOR_TYPE_IDENTITY:
  635.                 $sequenceName = null;
  636.                 $fieldName    = $class->identifier ? $class->getSingleIdentifierFieldName() : null;
  637.                 $platform     = $this->getTargetPlatform();
  639.                 // Platforms that do not have native IDENTITY support need a sequence to emulate this behaviour.
  640.                 /** @psalm-suppress UndefinedClass, InvalidClass */
  641.                 if (! $platform instanceof MySQLPlatform && ! $platform instanceof SqlitePlatform && ! $platform instanceof SQLServerPlatform && $platform->usesSequenceEmulatedIdentityColumns()) {
  642.                     Deprecation::trigger(
  643.                         'doctrine/orm',
  644.                         'https://github.com/doctrine/orm/issues/8850',
  645.                         <<<'DEPRECATION'
  646. Context: Loading metadata for class %s
  647. Problem: Using identity columns emulated with a sequence is deprecated and will not be possible in Doctrine ORM 3.0.
  648. Solution: Use the SEQUENCE generator strategy instead.
  649. DEPRECATION
  650.                             ,
  651.                         $class->name,
  652.                         get_class($this->getTargetPlatform())
  653.                     );
  654.                     $columnName     = $class->getSingleIdentifierColumnName();
  655.                     $quoted         = isset($class->fieldMappings[$fieldName]['quoted']) || isset($class->table['quoted']);
  656.                     $sequencePrefix = $class->getSequencePrefix($this->getTargetPlatform());
  657.                     $sequenceName   = $this->getTargetPlatform()->getIdentitySequenceName($sequencePrefix, $columnName);
  658.                     $definition     = [
  659.                         'sequenceName' => $this->truncateSequenceName($sequenceName),
  660.                     ];
  662.                     if ($quoted) {
  663.                         $definition['quoted'] = true;
  664.                     }
  666.                     $sequenceName = $this
  667.                         ->em
  668.                         ->getConfiguration()
  669.                         ->getQuoteStrategy()
  670.                         ->getSequenceName($definition, $class, $this->getTargetPlatform());
  671.                 }
  673.                 $generator = $fieldName && $class->fieldMappings[$fieldName]['type'] === 'bigint'
  674.                     ? new BigIntegerIdentityGenerator($sequenceName)
  675.                     : new IdentityGenerator($sequenceName);
  677.                 $class->setIdGenerator($generator);
  679.                 break;
  681.             case ClassMetadata::GENERATOR_TYPE_SEQUENCE:
  682.                 // If there is no sequence definition yet, create a default definition
  683.                 $definition = $class->sequenceGeneratorDefinition;
  685.                 if (! $definition) {
  686.                     $fieldName    = $class->getSingleIdentifierFieldName();
  687.                     $sequenceName = $class->getSequenceName($this->getTargetPlatform());
  688.                     $quoted       = isset($class->fieldMappings[$fieldName]['quoted']) || isset($class->table['quoted']);
  690.                     $definition = [
  691.                         'sequenceName'      => $this->truncateSequenceName($sequenceName),
  692.                         'allocationSize'    => 1,
  693.                         'initialValue'      => 1,
  694.                     ];
  696.                     if ($quoted) {
  697.                         $definition['quoted'] = true;
  698.                     }
  700.                     $class->setSequenceGeneratorDefinition($definition);
  701.                 }
  703.                 $sequenceGenerator = new SequenceGenerator(
  704.                     $this->em->getConfiguration()->getQuoteStrategy()->getSequenceName($definition, $class, $this->getTargetPlatform()),
  705.                     (int) $definition['allocationSize']
  706.                 );
  707.                 $class->setIdGenerator($sequenceGenerator);
  708.                 break;
  710.             case ClassMetadata::GENERATOR_TYPE_NONE:
  711.                 $class->setIdGenerator(new AssignedGenerator());
  712.                 break;
  714.             case ClassMetadata::GENERATOR_TYPE_UUID:
  715.                 Deprecation::trigger(
  716.                     'doctrine/orm',
  717.                     'https://github.com/doctrine/orm/issues/7312',
  718.                     'Mapping for %s: the "UUID" id generator strategy is deprecated with no replacement',
  719.                     $class->name
  720.                 );
  721.                 $class->setIdGenerator(new UuidGenerator());
  722.                 break;
  724.             case ClassMetadata::GENERATOR_TYPE_CUSTOM:
  725.                 $definition = $class->customGeneratorDefinition;
  726.                 if ($definition === null) {
  727.                     throw InvalidCustomGenerator::onClassNotConfigured();
  728.                 }
  730.                 if (! class_exists($definition['class'])) {
  731.                     throw InvalidCustomGenerator::onMissingClass($definition);
  732.                 }
  734.                 $class->setIdGenerator(new $definition['class']());
  735.                 break;
  737.             default:
  738.                 throw UnknownGeneratorType::create($class->generatorType);
  739.         }
  740.     }
  742.     /** @psalm-return ClassMetadata::GENERATOR_TYPE_* */
  743.     private function determineIdGeneratorStrategy(AbstractPlatform $platform): int
  744.     {
  745.         assert($this->em !== null);
  746.         foreach ($this->em->getConfiguration()->getIdentityGenerationPreferences() as $platformFamily => $strategy) {
  747.             if (is_a($platform, $platformFamily)) {
  748.                 return $strategy;
  749.             }
  750.         }
  752.         foreach (self::NON_IDENTITY_DEFAULT_STRATEGY as $platformFamily => $strategy) {
  753.             if (is_a($platform, $platformFamily)) {
  754.                 if ($platform instanceof Platforms\PostgreSQLPlatform || is_a($platform, 'Doctrine\DBAL\Platforms\PostgreSqlPlatform')) {
  755.                     Deprecation::trigger(
  756.                         'doctrine/orm',
  757.                         'https://github.com/doctrine/orm/issues/8893',
  758.                         <<<'DEPRECATION'
  759. Relying on non-optimal defaults for ID generation is deprecated, and IDENTITY
  760. results in SERIAL, which is not recommended.
  761. Instead, configure identifier generation strategies explicitly through
  762. configuration.
  763. We currently recommend "SEQUENCE" for "%s", so you should use
  764. $configuration->setIdentityGenerationPreferences([
  765.     "%s" => ClassMetadata::GENERATOR_TYPE_SEQUENCE,
  766. ]);
  767. DEPRECATION
  768.                         ,
  769.                         $platformFamily,
  770.                         $platformFamily
  771.                     );
  772.                 }
  774.                 return $strategy;
  775.             }
  776.         }
  778.         if ($platform->supportsIdentityColumns()) {
  779.             return ClassMetadata::GENERATOR_TYPE_IDENTITY;
  780.         }
  782.         if ($platform->supportsSequences()) {
  783.             return ClassMetadata::GENERATOR_TYPE_SEQUENCE;
  784.         }
  786.         throw CannotGenerateIds::withPlatform($platform);
  787.     }
  789.     private function truncateSequenceName(string $schemaElementName): string
  790.     {
  791.         $platform = $this->getTargetPlatform();
  792.         if (! $platform instanceof Platforms\OraclePlatform && ! $platform instanceof Platforms\SQLAnywherePlatform) {
  793.             return $schemaElementName;
  794.         }
  796.         $maxIdentifierLength = $platform->getMaxIdentifierLength();
  798.         if (strlen($schemaElementName) > $maxIdentifierLength) {
  799.             return substr($schemaElementName, 0, $maxIdentifierLength);
  800.         }
  802.         return $schemaElementName;
  803.     }
  805.     /**
  806.      * Inherits the ID generator mapping from a parent class.
  807.      */
  808.     private function inheritIdGeneratorMapping(ClassMetadataInfo $class, ClassMetadataInfo $parent): void
  809.     {
  810.         if ($parent->isIdGeneratorSequence()) {
  811.             $class->setSequenceGeneratorDefinition($parent->sequenceGeneratorDefinition);
  812.         }
  814.         if ($parent->generatorType) {
  815.             $class->setIdGeneratorType($parent->generatorType);
  816.         }
  818.         if ($parent->idGenerator) {
  819.             $class->setIdGenerator($parent->idGenerator);
  820.         }
  821.     }
  823.     /**
  824.      * {@inheritDoc}
  825.      */
  826.     protected function wakeupReflection(ClassMetadataInterface $class, ReflectionService $reflService)
  827.     {
  828.         assert($class instanceof ClassMetadata);
  829.         $class->wakeupReflection($reflService);
  830.     }
  832.     /**
  833.      * {@inheritDoc}
  834.      */
  835.     protected function initializeReflection(ClassMetadataInterface $class, ReflectionService $reflService)
  836.     {
  837.         assert($class instanceof ClassMetadata);
  838.         $class->initializeReflection($reflService);
  839.     }
  841.     /**
  842.      * @deprecated This method will be removed in ORM 3.0.
  843.      *
  844.      * @return class-string
  845.      */
  846.     protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
  847.     {
  848.         /** @psalm-var class-string */
  849.         return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  850.     }
  852.     /**
  853.      * {@inheritDoc}
  854.      */
  855.     protected function getDriver()
  856.     {
  857.         return $this->driver;
  858.     }
  860.     /**
  861.      * {@inheritDoc}
  862.      */
  863.     protected function isEntity(ClassMetadataInterface $class)
  864.     {
  865.         return ! $class->isMappedSuperclass;
  866.     }
  868.     private function getTargetPlatform(): Platforms\AbstractPlatform
  869.     {
  870.         if (! $this->targetPlatform) {
  871.             $this->targetPlatform = $this->em->getConnection()->getDatabasePlatform();
  872.         }
  874.         return $this->targetPlatform;
  875.     }
  876. }