vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/ClassMetadataFactory.php line 248

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ORM\Mapping;
  22. use Doctrine\DBAL\Platforms;
  23. use Doctrine\ORM\EntityManagerInterface;
  24. use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
  25. use Doctrine\ORM\Event\OnClassMetadataNotFoundEventArgs;
  26. use Doctrine\ORM\Events;
  27. use Doctrine\ORM\Id\BigIntegerIdentityGenerator;
  28. use Doctrine\ORM\Id\IdentityGenerator;
  29. use Doctrine\ORM\ORMException;
  30. use Doctrine\Persistence\Mapping\AbstractClassMetadataFactory;
  31. use Doctrine\Persistence\Mapping\ClassMetadata as ClassMetadataInterface;
  32. use Doctrine\Persistence\Mapping\Driver\MappingDriver;
  33. use Doctrine\Persistence\Mapping\ReflectionService;
  34. use ReflectionClass;
  35. use ReflectionException;
  36. use function interface_exists;
  38. /**
  39.  * The ClassMetadataFactory is used to create ClassMetadata objects that contain all the
  40.  * metadata mapping information of a class which describes how a class should be mapped
  41.  * to a relational database.
  42.  *
  43.  * @since   2.0
  44.  * @author  Benjamin Eberlei <kontakt@beberlei.de>
  45.  * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
  46.  * @author  Jonathan Wage <jonwage@gmail.com>
  47.  * @author  Roman Borschel <roman@code-factory.org>
  48.  */
  49. class ClassMetadataFactory extends AbstractClassMetadataFactory
  50. {
  51.     /**
  52.      * @var EntityManagerInterface|null
  53.      */
  54.     private $em;
  56.     /**
  57.      * @var \Doctrine\DBAL\Platforms\AbstractPlatform
  58.      */
  59.     private $targetPlatform;
  61.     /**
  62.      * @var MappingDriver
  63.      */
  64.     private $driver;
  66.     /**
  67.      * @var \Doctrine\Common\EventManager
  68.      */
  69.     private $evm;
  71.     /**
  72.      * @var array
  73.      */
  74.     private $embeddablesActiveNesting = [];
  76.     /**
  77.      * {@inheritDoc}
  78.      */
  79.     protected function loadMetadata($name)
  80.     {
  81.         $loaded = parent::loadMetadata($name);
  83.         array_map([$this, 'resolveDiscriminatorValue'], array_map([$this, 'getMetadataFor'], $loaded));
  85.         return $loaded;
  86.     }
  88.     /**
  89.      * @param EntityManagerInterface $em
  90.      */
  91.     public function setEntityManager(EntityManagerInterface $em)
  92.     {
  93.         $this->em = $em;
  94.     }
  96.     /**
  97.      * {@inheritDoc}
  98.      */
  99.     protected function initialize()
  100.     {
  101.         $this->driver = $this->em->getConfiguration()->getMetadataDriverImpl();
  102.         $this->evm = $this->em->getEventManager();
  103.         $this->initialized = true;
  104.     }
  106.     /**
  107.      * {@inheritDoc}
  108.      */
  109.     protected function onNotFoundMetadata($className)
  110.     {
  111.         if (! $this->evm->hasListeners(Events::onClassMetadataNotFound)) {
  112.             return;
  113.         }
  115.         $eventArgs = new OnClassMetadataNotFoundEventArgs($className, $this->em);
  117.         $this->evm->dispatchEvent(Events::onClassMetadataNotFound, $eventArgs);
  119.         return $eventArgs->getFoundMetadata();
  120.     }
  122.     /**
  123.      * {@inheritDoc}
  124.      */
  125.     protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
  126.     {
  127.         /* @var $class ClassMetadata */
  128.         /* @var $parent ClassMetadata */
  129.         if ($parent) {
  130.             $class->setInheritanceType($parent->inheritanceType);
  131.             $class->setDiscriminatorColumn($parent->discriminatorColumn);
  132.             $class->setIdGeneratorType($parent->generatorType);
  133.             $this->addInheritedFields($class, $parent);
  134.             $this->addInheritedRelations($class, $parent);
  135.             $this->addInheritedEmbeddedClasses($class, $parent);
  136.             $class->setIdentifier($parent->identifier);
  137.             $class->setVersioned($parent->isVersioned);
  138.             $class->setVersionField($parent->versionField);
  139.             $class->setDiscriminatorMap($parent->discriminatorMap);
  140.             $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
  141.             $class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
  143.             if ( ! empty($parent->customGeneratorDefinition)) {
  144.                 $class->setCustomGeneratorDefinition($parent->customGeneratorDefinition);
  145.             }
  147.             if ($parent->isMappedSuperclass) {
  148.                 $class->setCustomRepositoryClass($parent->customRepositoryClassName);
  149.             }
  150.         }
  152.         // Invoke driver
  153.         try {
  154.             $this->driver->loadMetadataForClass($class->getName(), $class);
  155.         } catch (ReflectionException $e) {
  156.             throw MappingException::reflectionFailure($class->getName(), $e);
  157.         }
  159.         // If this class has a parent the id generator strategy is inherited.
  160.         // However this is only true if the hierarchy of parents contains the root entity,
  161.         // if it consists of mapped superclasses these don't necessarily include the id field.
  162.         if ($parent && $rootEntityFound) {
  163.             $this->inheritIdGeneratorMapping($class, $parent);
  164.         } else {
  165.             $this->completeIdGeneratorMapping($class);
  166.         }
  168.         if (!$class->isMappedSuperclass) {
  169.             foreach ($class->embeddedClasses as $property => $embeddableClass) {
  171.                 if (isset($embeddableClass['inherited'])) {
  172.                     continue;
  173.                 }
  175.                 if ( ! (isset($embeddableClass['class']) && $embeddableClass['class'])) {
  176.                     throw MappingException::missingEmbeddedClass($property);
  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.             if ($parent) {
  209.                 $this->addInheritedIndexes($class, $parent);
  210.             }
  212.             if ($parent->cache) {
  213.                 $class->cache = $parent->cache;
  214.             }
  216.             if ($parent->containsForeignIdentifier) {
  217.                 $class->containsForeignIdentifier = true;
  218.             }
  220.             if ( ! empty($parent->namedQueries)) {
  221.                 $this->addInheritedNamedQueries($class, $parent);
  222.             }
  224.             if ( ! empty($parent->namedNativeQueries)) {
  225.                 $this->addInheritedNamedNativeQueries($class, $parent);
  226.             }
  228.             if ( ! empty($parent->sqlResultSetMappings)) {
  229.                 $this->addInheritedSqlResultSetMappings($class, $parent);
  230.             }
  232.             if ( ! empty($parent->entityListeners) && empty($class->entityListeners)) {
  233.                 $class->entityListeners = $parent->entityListeners;
  234.             }
  235.         }
  237.         $class->setParentClasses($nonSuperclassParents);
  239.         if ($class->isRootEntity() && ! $class->isInheritanceTypeNone() && ! $class->discriminatorMap) {
  240.             $this->addDefaultDiscriminatorMap($class);
  241.         }
  243.         if ($this->evm->hasListeners(Events::loadClassMetadata)) {
  244.             $eventArgs = new LoadClassMetadataEventArgs($class, $this->em);
  245.             $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
  246.         }
  248.         $this->validateRuntimeMetadata($class, $parent);
  249.     }
  251.     /**
  252.      * Validate runtime metadata is correctly defined.
  253.      *
  254.      * @param ClassMetadata               $class
  255.      * @param ClassMetadataInterface|null $parent
  256.      *
  257.      * @return void
  258.      *
  259.      * @throws MappingException
  260.      */
  261.     protected function validateRuntimeMetadata($class, $parent)
  262.     {
  263.         if ( ! $class->reflClass ) {
  264.             // only validate if there is a reflection class instance
  265.             return;
  266.         }
  268.         $class->validateIdentifier();
  269.         $class->validateAssociations();
  270.         $class->validateLifecycleCallbacks($this->getReflectionService());
  272.         // verify inheritance
  273.         if ( ! $class->isMappedSuperclass && !$class->isInheritanceTypeNone()) {
  274.             if ( ! $parent) {
  275.                 if (count($class->discriminatorMap) == 0) {
  276.                     throw MappingException::missingDiscriminatorMap($class->name);
  277.                 }
  278.                 if ( ! $class->discriminatorColumn) {
  279.                     throw MappingException::missingDiscriminatorColumn($class->name);
  280.                 }
  281.                 foreach ($class->subClasses as $subClass) {
  282.                     if ((new ReflectionClass($subClass))->name !== $subClass) {
  283.                         throw MappingException::invalidClassInDiscriminatorMap($subClass, $class->name);
  284.                     }
  285.                 }
  286.             }
  287.         } else if ($class->isMappedSuperclass && $class->name == $class->rootEntityName && (count($class->discriminatorMap) || $class->discriminatorColumn)) {
  288.             // second condition is necessary for mapped superclasses in the middle of an inheritance hierarchy
  289.             throw MappingException::noInheritanceOnMappedSuperClass($class->name);
  290.         }
  291.     }
  293.     /**
  294.      * {@inheritDoc}
  295.      */
  296.     protected function newClassMetadataInstance($className)
  297.     {
  298.         return new ClassMetadata($className, $this->em->getConfiguration()->getNamingStrategy());
  299.     }
  301.     /**
  302.      * Populates the discriminator value of the given metadata (if not set) by iterating over discriminator
  303.      * map classes and looking for a fitting one.
  304.      *
  305.      * @param ClassMetadata $metadata
  306.      *
  307.      * @return void
  308.      *
  309.      * @throws MappingException
  310.      */
  311.     private function resolveDiscriminatorValue(ClassMetadata $metadata)
  312.     {
  313.         if ($metadata->discriminatorValue
  314.             || ! $metadata->discriminatorMap
  315.             || $metadata->isMappedSuperclass
  316.             || ! $metadata->reflClass
  317.             || $metadata->reflClass->isAbstract()
  318.         ) {
  319.             return;
  320.         }
  322.         // minor optimization: avoid loading related metadata when not needed
  323.         foreach ($metadata->discriminatorMap as $discriminatorValue => $discriminatorClass) {
  324.             if ($discriminatorClass === $metadata->name) {
  325.                 $metadata->discriminatorValue = $discriminatorValue;
  327.                 return;
  328.             }
  329.         }
  331.         // iterate over discriminator mappings and resolve actual referenced classes according to existing metadata
  332.         foreach ($metadata->discriminatorMap as $discriminatorValue => $discriminatorClass) {
  333.             if ($metadata->name === $this->getMetadataFor($discriminatorClass)->getName()) {
  334.                 $metadata->discriminatorValue = $discriminatorValue;
  336.                 return;
  337.             }
  338.         }
  340.         throw MappingException::mappedClassNotPartOfDiscriminatorMap($metadata->name, $metadata->rootEntityName);
  341.     }
  343.     /**
  344.      * Adds a default discriminator map if no one is given
  345.      *
  346.      * If an entity is of any inheritance type and does not contain a
  347.      * discriminator map, then the map is generated automatically. This process
  348.      * is expensive computation wise.
  349.      *
  350.      * The automatically generated discriminator map contains the lowercase short name of
  351.      * each class as key.
  352.      *
  353.      * @param \Doctrine\ORM\Mapping\ClassMetadata $class
  354.      *
  355.      * @throws MappingException
  356.      */
  357.     private function addDefaultDiscriminatorMap(ClassMetadata $class)
  358.     {
  359.         $allClasses = $this->driver->getAllClassNames();
  360.         $fqcn = $class->getName();
  361.         $map = [$this->getShortName($class->name) => $fqcn];
  363.         $duplicates = [];
  364.         foreach ($allClasses as $subClassCandidate) {
  365.             if (is_subclass_of($subClassCandidate, $fqcn)) {
  366.                 $shortName = $this->getShortName($subClassCandidate);
  368.                 if (isset($map[$shortName])) {
  369.                     $duplicates[] = $shortName;
  370.                 }
  372.                 $map[$shortName] = $subClassCandidate;
  373.             }
  374.         }
  376.         if ($duplicates) {
  377.             throw MappingException::duplicateDiscriminatorEntry($class->name, $duplicates, $map);
  378.         }
  380.         $class->setDiscriminatorMap($map);
  381.     }
  383.     /**
  384.      * Gets the lower-case short name of a class.
  385.      *
  386.      * @param string $className
  387.      *
  388.      * @return string
  389.      */
  390.     private function getShortName($className)
  391.     {
  392.         if (strpos($className, "\\") === false) {
  393.             return strtolower($className);
  394.         }
  396.         $parts = explode("\\", $className);
  398.         return strtolower(end($parts));
  399.     }
  401.     /**
  402.      * Adds inherited fields to the subclass mapping.
  403.      *
  404.      * @param \Doctrine\ORM\Mapping\ClassMetadata $subClass
  405.      * @param \Doctrine\ORM\Mapping\ClassMetadata $parentClass
  406.      *
  407.      * @return void
  408.      */
  409.     private function addInheritedFields(ClassMetadata $subClass, ClassMetadata $parentClass)
  410.     {
  411.         foreach ($parentClass->fieldMappings as $mapping) {
  412.             if (! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {
  413.                 $mapping['inherited'] = $parentClass->name;
  414.             }
  415.             if (! isset($mapping['declared'])) {
  416.                 $mapping['declared'] = $parentClass->name;
  417.             }
  418.             $subClass->addInheritedFieldMapping($mapping);
  419.         }
  420.         foreach ($parentClass->reflFields as $name => $field) {
  421.             $subClass->reflFields[$name] = $field;
  422.         }
  423.     }
  425.     /**
  426.      * Adds inherited association mappings to the subclass mapping.
  427.      *
  428.      * @param \Doctrine\ORM\Mapping\ClassMetadata $subClass
  429.      * @param \Doctrine\ORM\Mapping\ClassMetadata $parentClass
  430.      *
  431.      * @return void
  432.      *
  433.      * @throws MappingException
  434.      */
  435.     private function addInheritedRelations(ClassMetadata $subClass, ClassMetadata $parentClass)
  436.     {
  437.         foreach ($parentClass->associationMappings as $field => $mapping) {
  438.             if ($parentClass->isMappedSuperclass) {
  439.                 if ($mapping['type'] & ClassMetadata::TO_MANY && !$mapping['isOwningSide']) {
  440.                     throw MappingException::illegalToManyAssociationOnMappedSuperclass($parentClass->name, $field);
  441.                 }
  442.                 $mapping['sourceEntity'] = $subClass->name;
  443.             }
  445.             //$subclassMapping = $mapping;
  446.             if ( ! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {
  447.                 $mapping['inherited'] = $parentClass->name;
  448.             }
  449.             if ( ! isset($mapping['declared'])) {
  450.                 $mapping['declared'] = $parentClass->name;
  451.             }
  452.             $subClass->addInheritedAssociationMapping($mapping);
  453.         }
  454.     }
  456.     private function addInheritedEmbeddedClasses(ClassMetadata $subClass, ClassMetadata $parentClass)
  457.     {
  458.         foreach ($parentClass->embeddedClasses as $field => $embeddedClass) {
  459.             if ( ! isset($embeddedClass['inherited']) && ! $parentClass->isMappedSuperclass) {
  460.                 $embeddedClass['inherited'] = $parentClass->name;
  461.             }
  462.             if ( ! isset($embeddedClass['declared'])) {
  463.                 $embeddedClass['declared'] = $parentClass->name;
  464.             }
  466.             $subClass->embeddedClasses[$field] = $embeddedClass;
  467.         }
  468.     }
  470.     /**
  471.      * Adds nested embedded classes metadata to a parent class.
  472.      *
  473.      * @param ClassMetadata $subClass    Sub embedded class metadata to add nested embedded classes metadata from.
  474.      * @param ClassMetadata $parentClass Parent class to add nested embedded classes metadata to.
  475.      * @param string        $prefix      Embedded classes' prefix to use for nested embedded classes field names.
  476.      */
  477.     private function addNestedEmbeddedClasses(ClassMetadata $subClass, ClassMetadata $parentClass, $prefix)
  478.     {
  479.         foreach ($subClass->embeddedClasses as $property => $embeddableClass) {
  480.             if (isset($embeddableClass['inherited'])) {
  481.                 continue;
  482.             }
  484.             $embeddableMetadata = $this->getMetadataFor($embeddableClass['class']);
  486.             $parentClass->mapEmbedded(
  487.                 [
  488.                     'fieldName' => $prefix . '.' . $property,
  489.                     'class' => $embeddableMetadata->name,
  490.                     'columnPrefix' => $embeddableClass['columnPrefix'],
  491.                     'declaredField' => $embeddableClass['declaredField']
  492.                             ? $prefix . '.' . $embeddableClass['declaredField']
  493.                             : $prefix,
  494.                     'originalField' => $embeddableClass['originalField'] ?: $property,
  495.                 ]
  496.             );
  497.         }
  498.     }
  500.     /**
  501.      * Copy the table indices from the parent class superclass to the child class
  502.      *
  503.      * @param ClassMetadata $subClass
  504.      * @param ClassMetadata $parentClass
  505.      *
  506.      * @return void
  507.      */
  508.     private function addInheritedIndexes(ClassMetadata $subClass, ClassMetadata $parentClass)
  509.     {
  510.         if (! $parentClass->isMappedSuperclass) {
  511.             return;
  512.         }
  514.         foreach (['uniqueConstraints', 'indexes'] as $indexType) {
  515.             if (isset($parentClass->table[$indexType])) {
  516.                 foreach ($parentClass->table[$indexType] as $indexName => $index) {
  517.                     if (isset($subClass->table[$indexType][$indexName])) {
  518.                         continue; // Let the inheriting table override indices
  519.                     }
  521.                     $subClass->table[$indexType][$indexName] = $index;
  522.                 }
  523.             }
  524.         }
  525.     }
  527.     /**
  528.      * Adds inherited named queries to the subclass mapping.
  529.      *
  530.      * @since 2.2
  531.      *
  532.      * @param \Doctrine\ORM\Mapping\ClassMetadata $subClass
  533.      * @param \Doctrine\ORM\Mapping\ClassMetadata $parentClass
  534.      *
  535.      * @return void
  536.      */
  537.     private function addInheritedNamedQueries(ClassMetadata $subClass, ClassMetadata $parentClass)
  538.     {
  539.         foreach ($parentClass->namedQueries as $name => $query) {
  540.             if ( ! isset ($subClass->namedQueries[$name])) {
  541.                 $subClass->addNamedQuery(
  542.                     [
  543.                         'name'  => $query['name'],
  544.                         'query' => $query['query']
  545.                     ]
  546.                 );
  547.             }
  548.         }
  549.     }
  551.     /**
  552.      * Adds inherited named native queries to the subclass mapping.
  553.      *
  554.      * @since 2.3
  555.      *
  556.      * @param \Doctrine\ORM\Mapping\ClassMetadata $subClass
  557.      * @param \Doctrine\ORM\Mapping\ClassMetadata $parentClass
  558.      *
  559.      * @return void
  560.      */
  561.     private function addInheritedNamedNativeQueries(ClassMetadata $subClass, ClassMetadata $parentClass)
  562.     {
  563.         foreach ($parentClass->namedNativeQueries as $name => $query) {
  564.             if ( ! isset ($subClass->namedNativeQueries[$name])) {
  565.                 $subClass->addNamedNativeQuery(
  566.                     [
  567.                         'name'              => $query['name'],
  568.                         'query'             => $query['query'],
  569.                         'isSelfClass'       => $query['isSelfClass'],
  570.                         'resultSetMapping'  => $query['resultSetMapping'],
  571.                         'resultClass'       => $query['isSelfClass'] ? $subClass->name : $query['resultClass'],
  572.                     ]
  573.                 );
  574.             }
  575.         }
  576.     }
  578.     /**
  579.      * Adds inherited sql result set mappings to the subclass mapping.
  580.      *
  581.      * @since 2.3
  582.      *
  583.      * @param \Doctrine\ORM\Mapping\ClassMetadata $subClass
  584.      * @param \Doctrine\ORM\Mapping\ClassMetadata $parentClass
  585.      *
  586.      * @return void
  587.      */
  588.     private function addInheritedSqlResultSetMappings(ClassMetadata $subClass, ClassMetadata $parentClass)
  589.     {
  590.         foreach ($parentClass->sqlResultSetMappings as $name => $mapping) {
  591.             if ( ! isset ($subClass->sqlResultSetMappings[$name])) {
  592.                 $entities = [];
  593.                 foreach ($mapping['entities'] as $entity) {
  594.                     $entities[] = [
  595.                         'fields'                => $entity['fields'],
  596.                         'isSelfClass'           => $entity['isSelfClass'],
  597.                         'discriminatorColumn'   => $entity['discriminatorColumn'],
  598.                         'entityClass'           => $entity['isSelfClass'] ? $subClass->name : $entity['entityClass'],
  599.                     ];
  600.                 }
  602.                 $subClass->addSqlResultSetMapping(
  603.                     [
  604.                         'name'          => $mapping['name'],
  605.                         'columns'       => $mapping['columns'],
  606.                         'entities'      => $entities,
  607.                     ]
  608.                 );
  609.             }
  610.         }
  611.     }
  613.     /**
  614.      * Completes the ID generator mapping. If "auto" is specified we choose the generator
  615.      * most appropriate for the targeted database platform.
  616.      *
  617.      * @param ClassMetadataInfo $class
  618.      *
  619.      * @return void
  620.      *
  621.      * @throws ORMException
  622.      */
  623.     private function completeIdGeneratorMapping(ClassMetadataInfo $class)
  624.     {
  625.         $idGenType = $class->generatorType;
  626.         if ($idGenType == ClassMetadata::GENERATOR_TYPE_AUTO) {
  627.             if ($this->getTargetPlatform()->prefersSequences()) {
  628.                 $class->setIdGeneratorType(ClassMetadata::GENERATOR_TYPE_SEQUENCE);
  629.             } else if ($this->getTargetPlatform()->prefersIdentityColumns()) {
  630.                 $class->setIdGeneratorType(ClassMetadata::GENERATOR_TYPE_IDENTITY);
  631.             } else {
  632.                 $class->setIdGeneratorType(ClassMetadata::GENERATOR_TYPE_TABLE);
  633.             }
  634.         }
  636.         // Create & assign an appropriate ID generator instance
  637.         switch ($class->generatorType) {
  638.             case ClassMetadata::GENERATOR_TYPE_IDENTITY:
  639.                 $sequenceName = null;
  640.                 $fieldName    = $class->identifier ? $class->getSingleIdentifierFieldName() : null;
  642.                 // Platforms that do not have native IDENTITY support need a sequence to emulate this behaviour.
  643.                 if ($this->getTargetPlatform()->usesSequenceEmulatedIdentityColumns()) {
  644.                     $columnName     = $class->getSingleIdentifierColumnName();
  645.                     $quoted         = isset($class->fieldMappings[$fieldName]['quoted']) || isset($class->table['quoted']);
  646.                     $sequencePrefix = $class->getSequencePrefix($this->getTargetPlatform());
  647.                     $sequenceName   = $this->getTargetPlatform()->getIdentitySequenceName($sequencePrefix, $columnName);
  648.                     $definition     = [
  649.                         'sequenceName' => $this->getTargetPlatform()->fixSchemaElementName($sequenceName)
  650.                     ];
  652.                     if ($quoted) {
  653.                         $definition['quoted'] = true;
  654.                     }
  656.                     $sequenceName = $this
  657.                         ->em
  658.                         ->getConfiguration()
  659.                         ->getQuoteStrategy()
  660.                         ->getSequenceName($definition, $class, $this->getTargetPlatform());
  661.                 }
  663.                 $generator = ($fieldName && $class->fieldMappings[$fieldName]['type'] === 'bigint')
  664.                     ? new BigIntegerIdentityGenerator($sequenceName)
  665.                     : new IdentityGenerator($sequenceName);
  667.                 $class->setIdGenerator($generator);
  669.                 break;
  671.             case ClassMetadata::GENERATOR_TYPE_SEQUENCE:
  672.                 // If there is no sequence definition yet, create a default definition
  673.                 $definition = $class->sequenceGeneratorDefinition;
  675.                 if ( ! $definition) {
  676.                     $fieldName      = $class->getSingleIdentifierFieldName();
  677.                     $sequenceName   = $class->getSequenceName($this->getTargetPlatform());
  678.                     $quoted         = isset($class->fieldMappings[$fieldName]['quoted']) || isset($class->table['quoted']);
  680.                     $definition = [
  681.                         'sequenceName'      => $this->getTargetPlatform()->fixSchemaElementName($sequenceName),
  682.                         'allocationSize'    => 1,
  683.                         'initialValue'      => 1,
  684.                     ];
  686.                     if ($quoted) {
  687.                         $definition['quoted'] = true;
  688.                     }
  690.                     $class->setSequenceGeneratorDefinition($definition);
  691.                 }
  693.                 $sequenceGenerator = new \Doctrine\ORM\Id\SequenceGenerator(
  694.                     $this->em->getConfiguration()->getQuoteStrategy()->getSequenceName($definition, $class, $this->getTargetPlatform()),
  695.                     $definition['allocationSize']
  696.                 );
  697.                 $class->setIdGenerator($sequenceGenerator);
  698.                 break;
  700.             case ClassMetadata::GENERATOR_TYPE_NONE:
  701.                 $class->setIdGenerator(new \Doctrine\ORM\Id\AssignedGenerator());
  702.                 break;
  704.             case ClassMetadata::GENERATOR_TYPE_UUID:
  705.                 $class->setIdGenerator(new \Doctrine\ORM\Id\UuidGenerator());
  706.                 break;
  708.             case ClassMetadata::GENERATOR_TYPE_TABLE:
  709.                 throw new ORMException("TableGenerator not yet implemented.");
  710.                 break;
  712.             case ClassMetadata::GENERATOR_TYPE_CUSTOM:
  713.                 $definition = $class->customGeneratorDefinition;
  714.                 if ($definition === null) {
  715.                     throw new ORMException("Can't instantiate custom generator : no custom generator definition");
  716.                 }
  717.                 if ( ! class_exists($definition['class'])) {
  718.                     throw new ORMException("Can't instantiate custom generator : " .
  719.                         $definition['class']);
  720.                 }
  721.                 $class->setIdGenerator(new $definition['class']);
  722.                 break;
  724.             default:
  725.                 throw new ORMException("Unknown generator type: " . $class->generatorType);
  726.         }
  727.     }
  729.     /**
  730.      * Inherits the ID generator mapping from a parent class.
  731.      *
  732.      * @param ClassMetadataInfo $class
  733.      * @param ClassMetadataInfo $parent
  734.      */
  735.     private function inheritIdGeneratorMapping(ClassMetadataInfo $class, ClassMetadataInfo $parent)
  736.     {
  737.         if ($parent->isIdGeneratorSequence()) {
  738.             $class->setSequenceGeneratorDefinition($parent->sequenceGeneratorDefinition);
  739.         } elseif ($parent->isIdGeneratorTable()) {
  740.             $class->tableGeneratorDefinition = $parent->tableGeneratorDefinition;
  741.         }
  743.         if ($parent->generatorType) {
  744.             $class->setIdGeneratorType($parent->generatorType);
  745.         }
  747.         if ($parent->idGenerator) {
  748.             $class->setIdGenerator($parent->idGenerator);
  749.         }
  750.     }
  752.     /**
  753.      * {@inheritDoc}
  754.      */
  755.     protected function wakeupReflection(ClassMetadataInterface $class, ReflectionService $reflService)
  756.     {
  757.         /* @var $class ClassMetadata */
  758.         $class->wakeupReflection($reflService);
  759.     }
  761.     /**
  762.      * {@inheritDoc}
  763.      */
  764.     protected function initializeReflection(ClassMetadataInterface $class, ReflectionService $reflService)
  765.     {
  766.         /* @var $class ClassMetadata */
  767.         $class->initializeReflection($reflService);
  768.     }
  770.     /**
  771.      * {@inheritDoc}
  772.      */
  773.     protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
  774.     {
  775.         return $this->em->getConfiguration()->getEntityNamespace($namespaceAlias) . '\\' . $simpleClassName;
  776.     }
  778.     /**
  779.      * {@inheritDoc}
  780.      */
  781.     protected function getDriver()
  782.     {
  783.         return $this->driver;
  784.     }
  786.     /**
  787.      * {@inheritDoc}
  788.      */
  789.     protected function isEntity(ClassMetadataInterface $class)
  790.     {
  791.         return isset($class->isMappedSuperclass) && $class->isMappedSuperclass === false;
  792.     }
  794.     /**
  795.      * @return Platforms\AbstractPlatform
  796.      */
  797.     private function getTargetPlatform()
  798.     {
  799.         if (!$this->targetPlatform) {
  800.             $this->targetPlatform = $this->em->getConnection()->getDatabasePlatform();
  801.         }
  803.         return $this->targetPlatform;
  804.     }
  805. }