vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/ClassMetadataInfo.php line 1037

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 BadMethodCallException;
  23. use Doctrine\DBAL\Types\Type;
  24. use Doctrine\DBAL\Platforms\AbstractPlatform;
  25. use Doctrine\Instantiator\Instantiator;
  26. use Doctrine\ORM\Cache\CacheException;
  27. use Doctrine\Persistence\Mapping\ClassMetadata;
  28. use Doctrine\Persistence\Mapping\ReflectionService;
  29. use InvalidArgumentException;
  30. use ReflectionClass;
  31. use ReflectionProperty;
  32. use RuntimeException;
  33. use function count;
  34. use function explode;
  36. /**
  37.  * A <tt>ClassMetadata</tt> instance holds all the object-relational mapping metadata
  38.  * of an entity and its associations.
  39.  *
  40.  * Once populated, ClassMetadata instances are usually cached in a serialized form.
  41.  *
  42.  * <b>IMPORTANT NOTE:</b>
  43.  *
  44.  * The fields of this class are only public for 2 reasons:
  45.  * 1) To allow fast READ access.
  46.  * 2) To drastically reduce the size of a serialized instance (private/protected members
  47.  *    get the whole class name, namespace inclusive, prepended to every property in
  48.  *    the serialized representation).
  49.  *
  50.  * @author Roman Borschel <roman@code-factory.org>
  51.  * @author Jonathan H. Wage <jonwage@gmail.com>
  52.  * @since 2.0
  53.  */
  54. class ClassMetadataInfo implements ClassMetadata
  55. {
  56.     /* The inheritance mapping types */
  57.     /**
  58.      * NONE means the class does not participate in an inheritance hierarchy
  59.      * and therefore does not need an inheritance mapping type.
  60.      */
  61.     const INHERITANCE_TYPE_NONE = 1;
  63.     /**
  64.      * JOINED means the class will be persisted according to the rules of
  65.      * <tt>Class Table Inheritance</tt>.
  66.      */
  67.     const INHERITANCE_TYPE_JOINED = 2;
  69.     /**
  70.      * SINGLE_TABLE means the class will be persisted according to the rules of
  71.      * <tt>Single Table Inheritance</tt>.
  72.      */
  73.     const INHERITANCE_TYPE_SINGLE_TABLE = 3;
  75.     /**
  76.      * TABLE_PER_CLASS means the class will be persisted according to the rules
  77.      * of <tt>Concrete Table Inheritance</tt>.
  78.      */
  79.     const INHERITANCE_TYPE_TABLE_PER_CLASS = 4;
  81.     /* The Id generator types. */
  82.     /**
  83.      * AUTO means the generator type will depend on what the used platform prefers.
  84.      * Offers full portability.
  85.      */
  86.     const GENERATOR_TYPE_AUTO = 1;
  88.     /**
  89.      * SEQUENCE means a separate sequence object will be used. Platforms that do
  90.      * not have native sequence support may emulate it. Full portability is currently
  91.      * not guaranteed.
  92.      */
  93.     const GENERATOR_TYPE_SEQUENCE = 2;
  95.     /**
  96.      * TABLE means a separate table is used for id generation.
  97.      * Offers full portability.
  98.      */
  99.     const GENERATOR_TYPE_TABLE = 3;
  101.     /**
  102.      * IDENTITY means an identity column is used for id generation. The database
  103.      * will fill in the id column on insertion. Platforms that do not support
  104.      * native identity columns may emulate them. Full portability is currently
  105.      * not guaranteed.
  106.      */
  107.     const GENERATOR_TYPE_IDENTITY = 4;
  109.     /**
  110.      * NONE means the class does not have a generated id. That means the class
  111.      * must have a natural, manually assigned id.
  112.      */
  113.     const GENERATOR_TYPE_NONE = 5;
  115.     /**
  116.      * UUID means that a UUID/GUID expression is used for id generation. Full
  117.      * portability is currently not guaranteed.
  118.      */
  119.     const GENERATOR_TYPE_UUID = 6;
  121.     /**
  122.      * CUSTOM means that customer will use own ID generator that supposedly work
  123.      */
  124.     const GENERATOR_TYPE_CUSTOM = 7;
  126.     /**
  127.      * DEFERRED_IMPLICIT means that changes of entities are calculated at commit-time
  128.      * by doing a property-by-property comparison with the original data. This will
  129.      * be done for all entities that are in MANAGED state at commit-time.
  130.      *
  131.      * This is the default change tracking policy.
  132.      */
  133.     const CHANGETRACKING_DEFERRED_IMPLICIT = 1;
  135.     /**
  136.      * DEFERRED_EXPLICIT means that changes of entities are calculated at commit-time
  137.      * by doing a property-by-property comparison with the original data. This will
  138.      * be done only for entities that were explicitly saved (through persist() or a cascade).
  139.      */
  140.     const CHANGETRACKING_DEFERRED_EXPLICIT = 2;
  142.     /**
  143.      * NOTIFY means that Doctrine relies on the entities sending out notifications
  144.      * when their properties change. Such entity classes must implement
  145.      * the <tt>NotifyPropertyChanged</tt> interface.
  146.      */
  147.     const CHANGETRACKING_NOTIFY = 3;
  149.     /**
  150.      * Specifies that an association is to be fetched when it is first accessed.
  151.      */
  152.     const FETCH_LAZY = 2;
  154.     /**
  155.      * Specifies that an association is to be fetched when the owner of the
  156.      * association is fetched.
  157.      */
  158.     const FETCH_EAGER = 3;
  160.     /**
  161.      * Specifies that an association is to be fetched lazy (on first access) and that
  162.      * commands such as Collection#count, Collection#slice are issued directly against
  163.      * the database if the collection is not yet initialized.
  164.      */
  165.     const FETCH_EXTRA_LAZY = 4;
  167.     /**
  168.      * Identifies a one-to-one association.
  169.      */
  170.     const ONE_TO_ONE = 1;
  172.     /**
  173.      * Identifies a many-to-one association.
  174.      */
  175.     const MANY_TO_ONE = 2;
  177.     /**
  178.      * Identifies a one-to-many association.
  179.      */
  180.     const ONE_TO_MANY = 4;
  182.     /**
  183.      * Identifies a many-to-many association.
  184.      */
  185.     const MANY_TO_MANY = 8;
  187.     /**
  188.      * Combined bitmask for to-one (single-valued) associations.
  189.      */
  190.     const TO_ONE = 3;
  192.     /**
  193.      * Combined bitmask for to-many (collection-valued) associations.
  194.      */
  195.     const TO_MANY = 12;
  197.     /**
  198.      * ReadOnly cache can do reads, inserts and deletes, cannot perform updates or employ any locks,
  199.      */
  200.     const CACHE_USAGE_READ_ONLY = 1;
  202.     /**
  203.      * Nonstrict Read Write Cache doesn’t employ any locks but can do inserts, update and deletes.
  204.      */
  205.     const CACHE_USAGE_NONSTRICT_READ_WRITE = 2;
  207.     /**
  208.      * Read Write Attempts to lock the entity before update/delete.
  209.      */
  210.     const CACHE_USAGE_READ_WRITE = 3;
  212.     /**
  213.      * READ-ONLY: The name of the entity class.
  214.      *
  215.      * @var string
  216.      */
  217.     public $name;
  219.     /**
  220.      * READ-ONLY: The namespace the entity class is contained in.
  221.      *
  222.      * @var string
  223.      *
  224.      * @todo Not really needed. Usage could be localized.
  225.      */
  226.     public $namespace;
  228.     /**
  229.      * READ-ONLY: The name of the entity class that is at the root of the mapped entity inheritance
  230.      * hierarchy. If the entity is not part of a mapped inheritance hierarchy this is the same
  231.      * as {@link $name}.
  232.      *
  233.      * @var string
  234.      */
  235.     public $rootEntityName;
  237.     /**
  238.      * READ-ONLY: The definition of custom generator. Only used for CUSTOM
  239.      * generator type
  240.      *
  241.      * The definition has the following structure:
  242.      * <code>
  243.      * array(
  244.      *     'class' => 'ClassName',
  245.      * )
  246.      * </code>
  247.      *
  248.      * @todo Merge with tableGeneratorDefinition into generic generatorDefinition
  249.      *
  250.      * @var array<string, string>|null
  251.      */
  252.     public $customGeneratorDefinition;
  254.     /**
  255.      * The name of the custom repository class used for the entity class.
  256.      * (Optional).
  257.      *
  258.      * @var string|null
  259.      * @psalm-var ?class-string
  260.      */
  261.     public $customRepositoryClassName;
  263.     /**
  264.      * READ-ONLY: Whether this class describes the mapping of a mapped superclass.
  265.      *
  266.      * @var boolean
  267.      */
  268.     public $isMappedSuperclass = false;
  270.     /**
  271.      * READ-ONLY: Whether this class describes the mapping of an embeddable class.
  272.      *
  273.      * @var boolean
  274.      */
  275.     public $isEmbeddedClass = false;
  277.     /**
  278.      * READ-ONLY: The names of the parent classes (ancestors).
  279.      *
  280.      * @var array
  281.      */
  282.     public $parentClasses = [];
  284.     /**
  285.      * READ-ONLY: The names of all subclasses (descendants).
  286.      *
  287.      * @var array
  288.      */
  289.     public $subClasses = [];
  291.     /**
  292.      * READ-ONLY: The names of all embedded classes based on properties.
  293.      *
  294.      * @var array
  295.      */
  296.     public $embeddedClasses = [];
  298.     /**
  299.      * READ-ONLY: The named queries allowed to be called directly from Repository.
  300.      *
  301.      * @var array
  302.      */
  303.     public $namedQueries = [];
  305.     /**
  306.      * READ-ONLY: The named native queries allowed to be called directly from Repository.
  307.      *
  308.      * A native SQL named query definition has the following structure:
  309.      * <pre>
  310.      * array(
  311.      *     'name'               => <query name>,
  312.      *     'query'              => <sql query>,
  313.      *     'resultClass'        => <class of the result>,
  314.      *     'resultSetMapping'   => <name of a SqlResultSetMapping>
  315.      * )
  316.      * </pre>
  317.      *
  318.      * @var array
  319.      */
  320.     public $namedNativeQueries = [];
  322.     /**
  323.      * READ-ONLY: The mappings of the results of native SQL queries.
  324.      *
  325.      * A native result mapping definition has the following structure:
  326.      * <pre>
  327.      * array(
  328.      *     'name'               => <result name>,
  329.      *     'entities'           => array(<entity result mapping>),
  330.      *     'columns'            => array(<column result mapping>)
  331.      * )
  332.      * </pre>
  333.      *
  334.      * @var array
  335.      */
  336.     public $sqlResultSetMappings = [];
  338.     /**
  339.      * READ-ONLY: The field names of all fields that are part of the identifier/primary key
  340.      * of the mapped entity class.
  341.      *
  342.      * @var array
  343.      */
  344.     public $identifier = [];
  346.     /**
  347.      * READ-ONLY: The inheritance mapping type used by the class.
  348.      *
  349.      * @var integer
  350.      */
  351.     public $inheritanceType = self::INHERITANCE_TYPE_NONE;
  353.     /**
  354.      * READ-ONLY: The Id generator type used by the class.
  355.      *
  356.      * @var int
  357.      */
  358.     public $generatorType = self::GENERATOR_TYPE_NONE;
  360.     /**
  361.      * READ-ONLY: The field mappings of the class.
  362.      * Keys are field names and values are mapping definitions.
  363.      *
  364.      * The mapping definition array has the following values:
  365.      *
  366.      * - <b>fieldName</b> (string)
  367.      * The name of the field in the Entity.
  368.      *
  369.      * - <b>type</b> (string)
  370.      * The type name of the mapped field. Can be one of Doctrine's mapping types
  371.      * or a custom mapping type.
  372.      *
  373.      * - <b>columnName</b> (string, optional)
  374.      * The column name. Optional. Defaults to the field name.
  375.      *
  376.      * - <b>length</b> (integer, optional)
  377.      * The database length of the column. Optional. Default value taken from
  378.      * the type.
  379.      *
  380.      * - <b>id</b> (boolean, optional)
  381.      * Marks the field as the primary key of the entity. Multiple fields of an
  382.      * entity can have the id attribute, forming a composite key.
  383.      *
  384.      * - <b>nullable</b> (boolean, optional)
  385.      * Whether the column is nullable. Defaults to FALSE.
  386.      *
  387.      * - <b>columnDefinition</b> (string, optional, schema-only)
  388.      * The SQL fragment that is used when generating the DDL for the column.
  389.      *
  390.      * - <b>precision</b> (integer, optional, schema-only)
  391.      * The precision of a decimal column. Only valid if the column type is decimal.
  392.      *
  393.      * - <b>scale</b> (integer, optional, schema-only)
  394.      * The scale of a decimal column. Only valid if the column type is decimal.
  395.      *
  396.      * - <b>'unique'</b> (string, optional, schema-only)
  397.      * Whether a unique constraint should be generated for the column.
  398.      *
  399.      * @var array
  400.      *
  401.      * @psalm-var array<string, array{type: string, fieldName: string, columnName: string, inherited: class-string}>
  402.      */
  403.     public $fieldMappings = [];
  405.     /**
  406.      * READ-ONLY: An array of field names. Used to look up field names from column names.
  407.      * Keys are column names and values are field names.
  408.      *
  409.      * @var array
  410.      */
  411.     public $fieldNames = [];
  413.     /**
  414.      * READ-ONLY: A map of field names to column names. Keys are field names and values column names.
  415.      * Used to look up column names from field names.
  416.      * This is the reverse lookup map of $_fieldNames.
  417.      *
  418.      * @var array
  419.      *
  420.      * @deprecated 3.0 Remove this.
  421.      */
  422.     public $columnNames = [];
  424.     /**
  425.      * READ-ONLY: The discriminator value of this class.
  426.      *
  427.      * <b>This does only apply to the JOINED and SINGLE_TABLE inheritance mapping strategies
  428.      * where a discriminator column is used.</b>
  429.      *
  430.      * @var mixed
  431.      *
  432.      * @see discriminatorColumn
  433.      */
  434.     public $discriminatorValue;
  436.     /**
  437.      * READ-ONLY: The discriminator map of all mapped classes in the hierarchy.
  438.      *
  439.      * <b>This does only apply to the JOINED and SINGLE_TABLE inheritance mapping strategies
  440.      * where a discriminator column is used.</b>
  441.      *
  442.      * @var mixed
  443.      *
  444.      * @see discriminatorColumn
  445.      */
  446.     public $discriminatorMap = [];
  448.     /**
  449.      * READ-ONLY: The definition of the discriminator column used in JOINED and SINGLE_TABLE
  450.      * inheritance mappings.
  451.      *
  452.      * @var array
  453.      */
  454.     public $discriminatorColumn;
  456.     /**
  457.      * READ-ONLY: The primary table definition. The definition is an array with the
  458.      * following entries:
  459.      *
  460.      * name => <tableName>
  461.      * schema => <schemaName>
  462.      * indexes => array
  463.      * uniqueConstraints => array
  464.      *
  465.      * @var array
  466.      */
  467.     public $table;
  469.     /**
  470.      * READ-ONLY: The registered lifecycle callbacks for entities of this class.
  471.      *
  472.      * @var array[]
  473.      */
  474.     public $lifecycleCallbacks = [];
  476.     /**
  477.      * READ-ONLY: The registered entity listeners.
  478.      *
  479.      * @var array
  480.      */
  481.     public $entityListeners = [];
  483.     /**
  484.      * READ-ONLY: The association mappings of this class.
  485.      *
  486.      * The mapping definition array supports the following keys:
  487.      *
  488.      * - <b>fieldName</b> (string)
  489.      * The name of the field in the entity the association is mapped to.
  490.      *
  491.      * - <b>targetEntity</b> (string)
  492.      * The class name of the target entity. If it is fully-qualified it is used as is.
  493.      * If it is a simple, unqualified class name the namespace is assumed to be the same
  494.      * as the namespace of the source entity.
  495.      *
  496.      * - <b>mappedBy</b> (string, required for bidirectional associations)
  497.      * The name of the field that completes the bidirectional association on the owning side.
  498.      * This key must be specified on the inverse side of a bidirectional association.
  499.      *
  500.      * - <b>inversedBy</b> (string, required for bidirectional associations)
  501.      * The name of the field that completes the bidirectional association on the inverse side.
  502.      * This key must be specified on the owning side of a bidirectional association.
  503.      *
  504.      * - <b>cascade</b> (array, optional)
  505.      * The names of persistence operations to cascade on the association. The set of possible
  506.      * values are: "persist", "remove", "detach", "merge", "refresh", "all" (implies all others).
  507.      *
  508.      * - <b>orderBy</b> (array, one-to-many/many-to-many only)
  509.      * A map of field names (of the target entity) to sorting directions (ASC/DESC).
  510.      * Example: array('priority' => 'desc')
  511.      *
  512.      * - <b>fetch</b> (integer, optional)
  513.      * The fetching strategy to use for the association, usually defaults to FETCH_LAZY.
  514.      * Possible values are: ClassMetadata::FETCH_EAGER, ClassMetadata::FETCH_LAZY.
  515.      *
  516.      * - <b>joinTable</b> (array, optional, many-to-many only)
  517.      * Specification of the join table and its join columns (foreign keys).
  518.      * Only valid for many-to-many mappings. Note that one-to-many associations can be mapped
  519.      * through a join table by simply mapping the association as many-to-many with a unique
  520.      * constraint on the join table.
  521.      *
  522.      * - <b>indexBy</b> (string, optional, to-many only)
  523.      * Specification of a field on target-entity that is used to index the collection by.
  524.      * This field HAS to be either the primary key or a unique column. Otherwise the collection
  525.      * does not contain all the entities that are actually related.
  526.      *
  527.      * A join table definition has the following structure:
  528.      * <pre>
  529.      * array(
  530.      *     'name' => <join table name>,
  531.      *      'joinColumns' => array(<join column mapping from join table to source table>),
  532.      *      'inverseJoinColumns' => array(<join column mapping from join table to target table>)
  533.      * )
  534.      * </pre>
  535.      *
  536.      * @var array
  537.      */
  538.     public $associationMappings = [];
  540.     /**
  541.      * READ-ONLY: Flag indicating whether the identifier/primary key of the class is composite.
  542.      *
  543.      * @var boolean
  544.      */
  545.     public $isIdentifierComposite = false;
  547.     /**
  548.      * READ-ONLY: Flag indicating whether the identifier/primary key contains at least one foreign key association.
  549.      *
  550.      * This flag is necessary because some code blocks require special treatment of this cases.
  551.      *
  552.      * @var boolean
  553.      */
  554.     public $containsForeignIdentifier = false;
  556.     /**
  557.      * READ-ONLY: The ID generator used for generating IDs for this class.
  558.      *
  559.      * @var \Doctrine\ORM\Id\AbstractIdGenerator
  560.      *
  561.      * @todo Remove!
  562.      */
  563.     public $idGenerator;
  565.     /**
  566.      * READ-ONLY: The definition of the sequence generator of this class. Only used for the
  567.      * SEQUENCE generation strategy.
  568.      *
  569.      * The definition has the following structure:
  570.      * <code>
  571.      * array(
  572.      *     'sequenceName' => 'name',
  573.      *     'allocationSize' => 20,
  574.      *     'initialValue' => 1
  575.      * )
  576.      * </code>
  577.      *
  578.      * @var array
  579.      *
  580.      * @todo Merge with tableGeneratorDefinition into generic generatorDefinition
  581.      */
  582.     public $sequenceGeneratorDefinition;
  584.     /**
  585.      * READ-ONLY: The definition of the table generator of this class. Only used for the
  586.      * TABLE generation strategy.
  587.      *
  588.      * @var array
  589.      *
  590.      * @todo Merge with tableGeneratorDefinition into generic generatorDefinition
  591.      */
  592.     public $tableGeneratorDefinition;
  594.     /**
  595.      * READ-ONLY: The policy used for change-tracking on entities of this class.
  596.      *
  597.      * @var integer
  598.      */
  599.     public $changeTrackingPolicy = self::CHANGETRACKING_DEFERRED_IMPLICIT;
  601.     /**
  602.      * READ-ONLY: A flag for whether or not instances of this class are to be versioned
  603.      * with optimistic locking.
  604.      *
  605.      * @var boolean
  606.      */
  607.     public $isVersioned;
  609.     /**
  610.      * READ-ONLY: The name of the field which is used for versioning in optimistic locking (if any).
  611.      *
  612.      * @var mixed
  613.      */
  614.     public $versionField;
  616.     /**
  617.      * @var array
  618.      */
  619.     public $cache = null;
  621.     /**
  622.      * The ReflectionClass instance of the mapped class.
  623.      *
  624.      * @var ReflectionClass
  625.      */
  626.     public $reflClass;
  628.     /**
  629.      * Is this entity marked as "read-only"?
  630.      *
  631.      * That means it is never considered for change-tracking in the UnitOfWork. It is a very helpful performance
  632.      * optimization for entities that are immutable, either in your domain or through the relation database
  633.      * (coming from a view, or a history table for example).
  634.      *
  635.      * @var bool
  636.      */
  637.     public $isReadOnly = false;
  639.     /**
  640.      * NamingStrategy determining the default column and table names.
  641.      *
  642.      * @var \Doctrine\ORM\Mapping\NamingStrategy
  643.      */
  644.     protected $namingStrategy;
  646.     /**
  647.      * The ReflectionProperty instances of the mapped class.
  648.      *
  649.      * @var ReflectionProperty[]|null[]
  650.      */
  651.     public $reflFields = [];
  653.     /**
  654.      * @var \Doctrine\Instantiator\InstantiatorInterface|null
  655.      */
  656.     private $instantiator;
  658.     /**
  659.      * Initializes a new ClassMetadata instance that will hold the object-relational mapping
  660.      * metadata of the class with the given name.
  661.      *
  662.      * @param string              $entityName     The name of the entity class the new instance is used for.
  663.      * @param NamingStrategy|null $namingStrategy
  664.      */
  665.     public function __construct($entityName, NamingStrategy $namingStrategy = null)
  666.     {
  667.         $this->name = $entityName;
  668.         $this->rootEntityName = $entityName;
  669.         $this->namingStrategy = $namingStrategy ?: new DefaultNamingStrategy();
  670.         $this->instantiator   = new Instantiator();
  671.     }
  673.     /**
  674.      * Gets the ReflectionProperties of the mapped class.
  675.      *
  676.      * @return ReflectionProperty[]|null[] An array of ReflectionProperty instances.
  677.      *
  678.      * @psalm-return array<ReflectionProperty|null>
  679.      */
  680.     public function getReflectionProperties()
  681.     {
  682.         return $this->reflFields;
  683.     }
  685.     /**
  686.      * Gets a ReflectionProperty for a specific field of the mapped class.
  687.      *
  688.      * @param string $name
  689.      *
  690.      * @return ReflectionProperty
  691.      */
  692.     public function getReflectionProperty($name)
  693.     {
  694.         return $this->reflFields[$name];
  695.     }
  697.     /**
  698.      * Gets the ReflectionProperty for the single identifier field.
  699.      *
  700.      * @return ReflectionProperty
  701.      *
  702.      * @throws BadMethodCallException If the class has a composite identifier.
  703.      */
  704.     public function getSingleIdReflectionProperty()
  705.     {
  706.         if ($this->isIdentifierComposite) {
  707.             throw new BadMethodCallException("Class " . $this->name . " has a composite identifier.");
  708.         }
  710.         return $this->reflFields[$this->identifier[0]];
  711.     }
  713.     /**
  714.      * Extracts the identifier values of an entity of this class.
  715.      *
  716.      * For composite identifiers, the identifier values are returned as an array
  717.      * with the same order as the field order in {@link identifier}.
  718.      *
  719.      * @param object $entity
  720.      *
  721.      * @return array
  722.      */
  723.     public function getIdentifierValues($entity)
  724.     {
  725.         if ($this->isIdentifierComposite) {
  726.             $id = [];
  728.             foreach ($this->identifier as $idField) {
  729.                 $value = $this->reflFields[$idField]->getValue($entity);
  731.                 if (null !== $value) {
  732.                     $id[$idField] = $value;
  733.                 }
  734.             }
  736.             return $id;
  737.         }
  739.         $id = $this->identifier[0];
  740.         $value = $this->reflFields[$id]->getValue($entity);
  742.         if (null === $value) {
  743.             return [];
  744.         }
  746.         return [$id => $value];
  747.     }
  749.     /**
  750.      * Populates the entity identifier of an entity.
  751.      *
  752.      * @param object $entity
  753.      * @param array  $id
  754.      *
  755.      * @return void
  756.      *
  757.      * @todo Rename to assignIdentifier()
  758.      */
  759.     public function setIdentifierValues($entity, array $id)
  760.     {
  761.         foreach ($id as $idField => $idValue) {
  762.             $this->reflFields[$idField]->setValue($entity, $idValue);
  763.         }
  764.     }
  766.     /**
  767.      * Sets the specified field to the specified value on the given entity.
  768.      *
  769.      * @param object $entity
  770.      * @param string $field
  771.      * @param mixed  $value
  772.      *
  773.      * @return void
  774.      */
  775.     public function setFieldValue($entity, $field, $value)
  776.     {
  777.         $this->reflFields[$field]->setValue($entity, $value);
  778.     }
  780.     /**
  781.      * Gets the specified field's value off the given entity.
  782.      *
  783.      * @param object $entity
  784.      * @param string $field
  785.      *
  786.      * @return mixed
  787.      */
  788.     public function getFieldValue($entity, $field)
  789.     {
  790.         return $this->reflFields[$field]->getValue($entity);
  791.     }
  793.     /**
  794.      * Creates a string representation of this instance.
  795.      *
  796.      * @return string The string representation of this instance.
  797.      *
  798.      * @todo Construct meaningful string representation.
  799.      */
  800.     public function __toString()
  801.     {
  802.         return __CLASS__ . '@' . spl_object_hash($this);
  803.     }
  805.     /**
  806.      * Determines which fields get serialized.
  807.      *
  808.      * It is only serialized what is necessary for best unserialization performance.
  809.      * That means any metadata properties that are not set or empty or simply have
  810.      * their default value are NOT serialized.
  811.      *
  812.      * Parts that are also NOT serialized because they can not be properly unserialized:
  813.      *      - reflClass (ReflectionClass)
  814.      *      - reflFields (ReflectionProperty array)
  815.      *
  816.      * @return string[] The names of all the fields that should be serialized.
  817.      */
  818.     public function __sleep()
  819.     {
  820.         // This metadata is always serialized/cached.
  821.         $serialized = [
  822.             'associationMappings',
  823.             'columnNames', //TODO: 3.0 Remove this. Can use fieldMappings[$fieldName]['columnName']
  824.             'fieldMappings',
  825.             'fieldNames',
  826.             'embeddedClasses',
  827.             'identifier',
  828.             'isIdentifierComposite', // TODO: REMOVE
  829.             'name',
  830.             'namespace', // TODO: REMOVE
  831.             'table',
  832.             'rootEntityName',
  833.             'idGenerator', //TODO: Does not really need to be serialized. Could be moved to runtime.
  834.         ];
  836.         // The rest of the metadata is only serialized if necessary.
  837.         if ($this->changeTrackingPolicy != self::CHANGETRACKING_DEFERRED_IMPLICIT) {
  838.             $serialized[] = 'changeTrackingPolicy';
  839.         }
  841.         if ($this->customRepositoryClassName) {
  842.             $serialized[] = 'customRepositoryClassName';
  843.         }
  845.         if ($this->inheritanceType != self::INHERITANCE_TYPE_NONE) {
  846.             $serialized[] = 'inheritanceType';
  847.             $serialized[] = 'discriminatorColumn';
  848.             $serialized[] = 'discriminatorValue';
  849.             $serialized[] = 'discriminatorMap';
  850.             $serialized[] = 'parentClasses';
  851.             $serialized[] = 'subClasses';
  852.         }
  854.         if ($this->generatorType != self::GENERATOR_TYPE_NONE) {
  855.             $serialized[] = 'generatorType';
  856.             if ($this->generatorType == self::GENERATOR_TYPE_SEQUENCE) {
  857.                 $serialized[] = 'sequenceGeneratorDefinition';
  858.             }
  859.         }
  861.         if ($this->isMappedSuperclass) {
  862.             $serialized[] = 'isMappedSuperclass';
  863.         }
  865.         if ($this->isEmbeddedClass) {
  866.             $serialized[] = 'isEmbeddedClass';
  867.         }
  869.         if ($this->containsForeignIdentifier) {
  870.             $serialized[] = 'containsForeignIdentifier';
  871.         }
  873.         if ($this->isVersioned) {
  874.             $serialized[] = 'isVersioned';
  875.             $serialized[] = 'versionField';
  876.         }
  878.         if ($this->lifecycleCallbacks) {
  879.             $serialized[] = 'lifecycleCallbacks';
  880.         }
  882.         if ($this->entityListeners) {
  883.             $serialized[] = 'entityListeners';
  884.         }
  886.         if ($this->namedQueries) {
  887.             $serialized[] = 'namedQueries';
  888.         }
  890.         if ($this->namedNativeQueries) {
  891.             $serialized[] = 'namedNativeQueries';
  892.         }
  894.         if ($this->sqlResultSetMappings) {
  895.             $serialized[] = 'sqlResultSetMappings';
  896.         }
  898.         if ($this->isReadOnly) {
  899.             $serialized[] = 'isReadOnly';
  900.         }
  902.         if ($this->customGeneratorDefinition) {
  903.             $serialized[] = "customGeneratorDefinition";
  904.         }
  906.         if ($this->cache) {
  907.             $serialized[] = 'cache';
  908.         }
  910.         return $serialized;
  911.     }
  913.     /**
  914.      * Creates a new instance of the mapped class, without invoking the constructor.
  915.      *
  916.      * @return object
  917.      */
  918.     public function newInstance()
  919.     {
  920.         return $this->instantiator->instantiate($this->name);
  921.     }
  923.     /**
  924.      * Restores some state that can not be serialized/unserialized.
  925.      *
  926.      * @param ReflectionService $reflService
  927.      *
  928.      * @return void
  929.      */
  930.     public function wakeupReflection($reflService)
  931.     {
  932.         // Restore ReflectionClass and properties
  933.         $this->reflClass    = $reflService->getClass($this->name);
  934.         $this->instantiator = $this->instantiator ?: new Instantiator();
  936.         $parentReflFields = [];
  938.         foreach ($this->embeddedClasses as $property => $embeddedClass) {
  939.             if (isset($embeddedClass['declaredField'])) {
  940.                 $parentReflFields[$property] = new ReflectionEmbeddedProperty(
  941.                     $parentReflFields[$embeddedClass['declaredField']],
  942.                     $reflService->getAccessibleProperty(
  943.                         $this->embeddedClasses[$embeddedClass['declaredField']]['class'],
  944.                         $embeddedClass['originalField']
  945.                     ),
  946.                     $this->embeddedClasses[$embeddedClass['declaredField']]['class']
  947.                 );
  949.                 continue;
  950.             }
  952.             $fieldRefl = $reflService->getAccessibleProperty(
  953.                 $embeddedClass['declared'] ?? $this->name,
  954.                 $property
  955.             );
  957.             $parentReflFields[$property] = $fieldRefl;
  958.             $this->reflFields[$property] = $fieldRefl;
  959.         }
  961.         foreach ($this->fieldMappings as $field => $mapping) {
  962.             if (isset($mapping['declaredField']) && isset($parentReflFields[$mapping['declaredField']])) {
  963.                 $this->reflFields[$field] = new ReflectionEmbeddedProperty(
  964.                     $parentReflFields[$mapping['declaredField']],
  965.                     $reflService->getAccessibleProperty($mapping['originalClass'], $mapping['originalField']),
  966.                     $mapping['originalClass']
  967.                 );
  968.                 continue;
  969.             }
  971.             $this->reflFields[$field] = isset($mapping['declared'])
  972.                 ? $reflService->getAccessibleProperty($mapping['declared'], $field)
  973.                 : $reflService->getAccessibleProperty($this->name, $field);
  974.         }
  976.         foreach ($this->associationMappings as $field => $mapping) {
  977.             $this->reflFields[$field] = isset($mapping['declared'])
  978.                 ? $reflService->getAccessibleProperty($mapping['declared'], $field)
  979.                 : $reflService->getAccessibleProperty($this->name, $field);
  980.         }
  981.     }
  983.     /**
  984.      * Initializes a new ClassMetadata instance that will hold the object-relational mapping
  985.      * metadata of the class with the given name.
  986.      *
  987.      * @param ReflectionService $reflService The reflection service.
  988.      *
  989.      * @return void
  990.      */
  991.     public function initializeReflection($reflService)
  992.     {
  993.         $this->reflClass = $reflService->getClass($this->name);
  994.         $this->namespace = $reflService->getClassNamespace($this->name);
  996.         if ($this->reflClass) {
  997.             $this->name = $this->rootEntityName = $this->reflClass->getName();
  998.         }
  1000.         $this->table['name'] = $this->namingStrategy->classToTableName($this->name);
  1001.     }
  1003.     /**
  1004.      * Validates Identifier.
  1005.      *
  1006.      * @return void
  1007.      *
  1008.      * @throws MappingException
  1009.      */
  1010.     public function validateIdentifier()
  1011.     {
  1012.         if ($this->isMappedSuperclass || $this->isEmbeddedClass) {
  1013.             return;
  1014.         }
  1016.         // Verify & complete identifier mapping
  1017.         if ( ! $this->identifier) {
  1018.             throw MappingException::identifierRequired($this->name);
  1019.         }
  1021.         if ($this->usesIdGenerator() && $this->isIdentifierComposite) {
  1022.             throw MappingException::compositeKeyAssignedIdGeneratorRequired($this->name);
  1023.         }
  1024.     }
  1026.     /**
  1027.      * Validates association targets actually exist.
  1028.      *
  1029.      * @return void
  1030.      *
  1031.      * @throws MappingException
  1032.      */
  1033.     public function validateAssociations()
  1034.     {
  1035.         foreach ($this->associationMappings as $mapping) {
  1036.             if (
  1037.                 ! class_exists($mapping['targetEntity'])
  1038.                 && ! interface_exists($mapping['targetEntity'])
  1039.                 && ! trait_exists($mapping['targetEntity'])
  1040.             ) {
  1041.                 throw MappingException::invalidTargetEntityClass($mapping['targetEntity'], $this->name, $mapping['fieldName']);
  1042.             }
  1043.         }
  1044.     }
  1046.     /**
  1047.      * Validates lifecycle callbacks.
  1048.      *
  1049.      * @param ReflectionService $reflService
  1050.      *
  1051.      * @return void
  1052.      *
  1053.      * @throws MappingException
  1054.      */
  1055.     public function validateLifecycleCallbacks($reflService)
  1056.     {
  1057.         foreach ($this->lifecycleCallbacks as $callbacks) {
  1058.             foreach ($callbacks as $callbackFuncName) {
  1059.                 if ( ! $reflService->hasPublicMethod($this->name, $callbackFuncName)) {
  1060.                     throw MappingException::lifecycleCallbackMethodNotFound($this->name, $callbackFuncName);
  1061.                 }
  1062.             }
  1063.         }
  1064.     }
  1066.     /**
  1067.      * {@inheritDoc}
  1068.      */
  1069.     public function getReflectionClass()
  1070.     {
  1071.         return $this->reflClass;
  1072.     }
  1074.     /**
  1075.      * @param array $cache
  1076.      *
  1077.      * @return void
  1078.      */
  1079.     public function enableCache(array $cache)
  1080.     {
  1081.         if ( ! isset($cache['usage'])) {
  1082.             $cache['usage'] = self::CACHE_USAGE_READ_ONLY;
  1083.         }
  1085.         if ( ! isset($cache['region'])) {
  1086.             $cache['region'] = strtolower(str_replace('\\', '_', $this->rootEntityName));
  1087.         }
  1089.         $this->cache = $cache;
  1090.     }
  1092.     /**
  1093.      * @param string $fieldName
  1094.      * @param array  $cache
  1095.      *
  1096.      * @return void
  1097.      */
  1098.     public function enableAssociationCache($fieldName, array $cache)
  1099.     {
  1100.         $this->associationMappings[$fieldName]['cache'] = $this->getAssociationCacheDefaults($fieldName, $cache);
  1101.     }
  1103.     /**
  1104.      * @param string $fieldName
  1105.      * @param array  $cache
  1106.      *
  1107.      * @return mixed[]
  1108.      *
  1109.      * @psalm-param array{usage: mixed, region: mixed} $cache
  1110.      * @psalm-return array{usage: mixed, region: mixed}
  1111.      */
  1112.     public function getAssociationCacheDefaults($fieldName, array $cache)
  1113.     {
  1114.         if ( ! isset($cache['usage'])) {
  1115.             $cache['usage'] = isset($this->cache['usage'])
  1116.                 ? $this->cache['usage']
  1117.                 : self::CACHE_USAGE_READ_ONLY;
  1118.         }
  1120.         if ( ! isset($cache['region'])) {
  1121.             $cache['region'] = strtolower(str_replace('\\', '_', $this->rootEntityName)) . '__' . $fieldName;
  1122.         }
  1124.         return $cache;
  1125.     }
  1127.     /**
  1128.      * Sets the change tracking policy used by this class.
  1129.      *
  1130.      * @param integer $policy
  1131.      *
  1132.      * @return void
  1133.      */
  1134.     public function setChangeTrackingPolicy($policy)
  1135.     {
  1136.         $this->changeTrackingPolicy = $policy;
  1137.     }
  1139.     /**
  1140.      * Whether the change tracking policy of this class is "deferred explicit".
  1141.      *
  1142.      * @return boolean
  1143.      */
  1144.     public function isChangeTrackingDeferredExplicit()
  1145.     {
  1146.         return self::CHANGETRACKING_DEFERRED_EXPLICIT === $this->changeTrackingPolicy;
  1147.     }
  1149.     /**
  1150.      * Whether the change tracking policy of this class is "deferred implicit".
  1151.      *
  1152.      * @return boolean
  1153.      */
  1154.     public function isChangeTrackingDeferredImplicit()
  1155.     {
  1156.         return self::CHANGETRACKING_DEFERRED_IMPLICIT === $this->changeTrackingPolicy;
  1157.     }
  1159.     /**
  1160.      * Whether the change tracking policy of this class is "notify".
  1161.      *
  1162.      * @return boolean
  1163.      */
  1164.     public function isChangeTrackingNotify()
  1165.     {
  1166.         return self::CHANGETRACKING_NOTIFY === $this->changeTrackingPolicy;
  1167.     }
  1169.     /**
  1170.      * Checks whether a field is part of the identifier/primary key field(s).
  1171.      *
  1172.      * @param string $fieldName The field name.
  1173.      *
  1174.      * @return boolean TRUE if the field is part of the table identifier/primary key field(s),
  1175.      *                 FALSE otherwise.
  1176.      */
  1177.     public function isIdentifier($fieldName)
  1178.     {
  1179.         if ( ! $this->identifier) {
  1180.             return false;
  1181.         }
  1183.         if ( ! $this->isIdentifierComposite) {
  1184.             return $fieldName === $this->identifier[0];
  1185.         }
  1187.         return in_array($fieldName, $this->identifier, true);
  1188.     }
  1190.     /**
  1191.      * Checks if the field is unique.
  1192.      *
  1193.      * @param string $fieldName The field name.
  1194.      *
  1195.      * @return boolean TRUE if the field is unique, FALSE otherwise.
  1196.      */
  1197.     public function isUniqueField($fieldName)
  1198.     {
  1199.         $mapping = $this->getFieldMapping($fieldName);
  1201.         return false !== $mapping && isset($mapping['unique']) && $mapping['unique'];
  1202.     }
  1204.     /**
  1205.      * Checks if the field is not null.
  1206.      *
  1207.      * @param string $fieldName The field name.
  1208.      *
  1209.      * @return boolean TRUE if the field is not null, FALSE otherwise.
  1210.      */
  1211.     public function isNullable($fieldName)
  1212.     {
  1213.         $mapping = $this->getFieldMapping($fieldName);
  1215.         return false !== $mapping && isset($mapping['nullable']) && $mapping['nullable'];
  1216.     }
  1218.     /**
  1219.      * Gets a column name for a field name.
  1220.      * If the column name for the field cannot be found, the given field name
  1221.      * is returned.
  1222.      *
  1223.      * @param string $fieldName The field name.
  1224.      *
  1225.      * @return string The column name.
  1226.      */
  1227.     public function getColumnName($fieldName)
  1228.     {
  1229.         return isset($this->columnNames[$fieldName])
  1230.             ? $this->columnNames[$fieldName]
  1231.             : $fieldName;
  1232.     }
  1234.     /**
  1235.      * Gets the mapping of a (regular) field that holds some data but not a
  1236.      * reference to another object.
  1237.      *
  1238.      * @param string $fieldName The field name.
  1239.      *
  1240.      * @return array The field mapping.
  1241.      *
  1242.      * @throws MappingException
  1243.      */
  1244.     public function getFieldMapping($fieldName)
  1245.     {
  1246.         if ( ! isset($this->fieldMappings[$fieldName])) {
  1247.             throw MappingException::mappingNotFound($this->name, $fieldName);
  1248.         }
  1250.         return $this->fieldMappings[$fieldName];
  1251.     }
  1253.     /**
  1254.      * Gets the mapping of an association.
  1255.      *
  1256.      * @see ClassMetadataInfo::$associationMappings
  1257.      *
  1258.      * @param string $fieldName The field name that represents the association in
  1259.      *                          the object model.
  1260.      *
  1261.      * @return array The mapping.
  1262.      *
  1263.      * @throws MappingException
  1264.      */
  1265.     public function getAssociationMapping($fieldName)
  1266.     {
  1267.         if ( ! isset($this->associationMappings[$fieldName])) {
  1268.             throw MappingException::mappingNotFound($this->name, $fieldName);
  1269.         }
  1271.         return $this->associationMappings[$fieldName];
  1272.     }
  1274.     /**
  1275.      * Gets all association mappings of the class.
  1276.      *
  1277.      * @return array
  1278.      */
  1279.     public function getAssociationMappings()
  1280.     {
  1281.         return $this->associationMappings;
  1282.     }
  1284.     /**
  1285.      * Gets the field name for a column name.
  1286.      * If no field name can be found the column name is returned.
  1287.      *
  1288.      * @param string $columnName The column name.
  1289.      *
  1290.      * @return string The column alias.
  1291.      */
  1292.     public function getFieldName($columnName)
  1293.     {
  1294.         return isset($this->fieldNames[$columnName])
  1295.             ? $this->fieldNames[$columnName]
  1296.             : $columnName;
  1297.     }
  1299.     /**
  1300.      * Gets the named query.
  1301.      *
  1302.      * @see ClassMetadataInfo::$namedQueries
  1303.      *
  1304.      * @param string $queryName The query name.
  1305.      *
  1306.      * @return string
  1307.      *
  1308.      * @throws MappingException
  1309.      */
  1310.     public function getNamedQuery($queryName)
  1311.     {
  1312.         if ( ! isset($this->namedQueries[$queryName])) {
  1313.             throw MappingException::queryNotFound($this->name, $queryName);
  1314.         }
  1316.         return $this->namedQueries[$queryName]['dql'];
  1317.     }
  1319.     /**
  1320.      * Gets all named queries of the class.
  1321.      *
  1322.      * @return array
  1323.      */
  1324.     public function getNamedQueries()
  1325.     {
  1326.         return $this->namedQueries;
  1327.     }
  1329.     /**
  1330.      * Gets the named native query.
  1331.      *
  1332.      * @see ClassMetadataInfo::$namedNativeQueries
  1333.      *
  1334.      * @param string $queryName The query name.
  1335.      *
  1336.      * @return array
  1337.      *
  1338.      * @throws MappingException
  1339.      */
  1340.     public function getNamedNativeQuery($queryName)
  1341.     {
  1342.         if ( ! isset($this->namedNativeQueries[$queryName])) {
  1343.             throw MappingException::queryNotFound($this->name, $queryName);
  1344.         }
  1346.         return $this->namedNativeQueries[$queryName];
  1347.     }
  1349.     /**
  1350.      * Gets all named native queries of the class.
  1351.      *
  1352.      * @return array
  1353.      */
  1354.     public function getNamedNativeQueries()
  1355.     {
  1356.         return $this->namedNativeQueries;
  1357.     }
  1359.     /**
  1360.      * Gets the result set mapping.
  1361.      *
  1362.      * @see ClassMetadataInfo::$sqlResultSetMappings
  1363.      *
  1364.      * @param string $name The result set mapping name.
  1365.      *
  1366.      * @return array
  1367.      *
  1368.      * @throws MappingException
  1369.      */
  1370.     public function getSqlResultSetMapping($name)
  1371.     {
  1372.         if ( ! isset($this->sqlResultSetMappings[$name])) {
  1373.             throw MappingException::resultMappingNotFound($this->name, $name);
  1374.         }
  1376.         return $this->sqlResultSetMappings[$name];
  1377.     }
  1379.     /**
  1380.      * Gets all sql result set mappings of the class.
  1381.      *
  1382.      * @return array
  1383.      */
  1384.     public function getSqlResultSetMappings()
  1385.     {
  1386.         return $this->sqlResultSetMappings;
  1387.     }
  1389.     /**
  1390.      * Validates & completes the given field mapping.
  1391.      *
  1392.      * @param array $mapping The field mapping to validate & complete.
  1393.      *
  1394.      * @return void
  1395.      *
  1396.      * @throws MappingException
  1397.      */
  1398.     protected function _validateAndCompleteFieldMapping(array &$mapping)
  1399.     {
  1400.         // Check mandatory fields
  1401.         if ( ! isset($mapping['fieldName']) || !$mapping['fieldName']) {
  1402.             throw MappingException::missingFieldName($this->name);
  1403.         }
  1405.         if ( ! isset($mapping['type'])) {
  1406.             // Default to string
  1407.             $mapping['type'] = 'string';
  1408.         }
  1410.         // Complete fieldName and columnName mapping
  1411.         if ( ! isset($mapping['columnName'])) {
  1412.             $mapping['columnName'] = $this->namingStrategy->propertyToColumnName($mapping['fieldName'], $this->name);
  1413.         }
  1415.         if ('`' === $mapping['columnName'][0]) {
  1416.             $mapping['columnName']  = trim($mapping['columnName'], '`');
  1417.             $mapping['quoted']      = true;
  1418.         }
  1420.         $this->columnNames[$mapping['fieldName']] = $mapping['columnName'];
  1422.         if (isset($this->fieldNames[$mapping['columnName']]) || ($this->discriminatorColumn && $this->discriminatorColumn['name'] === $mapping['columnName'])) {
  1423.             throw MappingException::duplicateColumnName($this->name, $mapping['columnName']);
  1424.         }
  1426.         $this->fieldNames[$mapping['columnName']] = $mapping['fieldName'];
  1428.         // Complete id mapping
  1429.         if (isset($mapping['id']) && true === $mapping['id']) {
  1430.             if ($this->versionField == $mapping['fieldName']) {
  1431.                 throw MappingException::cannotVersionIdField($this->name, $mapping['fieldName']);
  1432.             }
  1434.             if ( ! in_array($mapping['fieldName'], $this->identifier)) {
  1435.                 $this->identifier[] = $mapping['fieldName'];
  1436.             }
  1438.             // Check for composite key
  1439.             if ( ! $this->isIdentifierComposite && count($this->identifier) > 1) {
  1440.                 $this->isIdentifierComposite = true;
  1441.             }
  1442.         }
  1444.         if (Type::hasType($mapping['type']) && Type::getType($mapping['type'])->canRequireSQLConversion()) {
  1445.             if (isset($mapping['id']) && true === $mapping['id']) {
  1446.                  throw MappingException::sqlConversionNotAllowedForIdentifiers($this->name, $mapping['fieldName'], $mapping['type']);
  1447.             }
  1449.             $mapping['requireSQLConversion'] = true;
  1450.         }
  1451.     }
  1453.     /**
  1454.      * Validates & completes the basic mapping information that is common to all
  1455.      * association mappings (one-to-one, many-ot-one, one-to-many, many-to-many).
  1456.      *
  1457.      * @param array $mapping The mapping.
  1458.      *
  1459.      * @return mixed[] The updated mapping.
  1460.      *
  1461.      * @throws MappingException If something is wrong with the mapping.
  1462.      *
  1463.      * @psalm-return array{
  1464.      *                   mappedBy: mixed,
  1465.      *                   inversedBy: mixed,
  1466.      *                   isOwningSide: bool,
  1467.      *                   sourceEntity: string,
  1468.      *                   targetEntity: string,
  1469.      *                   fieldName: mixed,
  1470.      *                   fetch: mixed,
  1471.      *                   cascade: array<array-key,string>,
  1472.      *                   isCascadeRemove: bool,
  1473.      *                   isCascadePersist: bool,
  1474.      *                   isCascadeRefresh: bool,
  1475.      *                   isCascadeMerge: bool,
  1476.      *                   isCascadeDetach: bool
  1477.      *               }
  1478.      */
  1479.     protected function _validateAndCompleteAssociationMapping(array $mapping)
  1480.     {
  1481.         if ( ! isset($mapping['mappedBy'])) {
  1482.             $mapping['mappedBy'] = null;
  1483.         }
  1485.         if ( ! isset($mapping['inversedBy'])) {
  1486.             $mapping['inversedBy'] = null;
  1487.         }
  1489.         $mapping['isOwningSide'] = true; // assume owning side until we hit mappedBy
  1491.         if (empty($mapping['indexBy'])) {
  1492.             unset($mapping['indexBy']);
  1493.         }
  1495.         // If targetEntity is unqualified, assume it is in the same namespace as
  1496.         // the sourceEntity.
  1497.         $mapping['sourceEntity'] = $this->name;
  1499.         if (isset($mapping['targetEntity'])) {
  1500.             $mapping['targetEntity'] = $this->fullyQualifiedClassName($mapping['targetEntity']);
  1501.             $mapping['targetEntity'] = ltrim($mapping['targetEntity'], '\\');
  1502.         }
  1504.         if (($mapping['type'] & self::MANY_TO_ONE) > 0 && isset($mapping['orphanRemoval']) && $mapping['orphanRemoval']) {
  1505.             throw MappingException::illegalOrphanRemoval($this->name, $mapping['fieldName']);
  1506.         }
  1508.         // Complete id mapping
  1509.         if (isset($mapping['id']) && true === $mapping['id']) {
  1510.             if (isset($mapping['orphanRemoval']) && $mapping['orphanRemoval']) {
  1511.                 throw MappingException::illegalOrphanRemovalOnIdentifierAssociation($this->name, $mapping['fieldName']);
  1512.             }
  1514.             if ( ! in_array($mapping['fieldName'], $this->identifier)) {
  1515.                 if (isset($mapping['joinColumns']) && count($mapping['joinColumns']) >= 2) {
  1516.                     throw MappingException::cannotMapCompositePrimaryKeyEntitiesAsForeignId(
  1517.                         $mapping['targetEntity'], $this->name, $mapping['fieldName']
  1518.                     );
  1519.                 }
  1521.                 $this->identifier[] = $mapping['fieldName'];
  1522.                 $this->containsForeignIdentifier = true;
  1523.             }
  1525.             // Check for composite key
  1526.             if ( ! $this->isIdentifierComposite && count($this->identifier) > 1) {
  1527.                 $this->isIdentifierComposite = true;
  1528.             }
  1530.             if ($this->cache && !isset($mapping['cache'])) {
  1531.                 throw CacheException::nonCacheableEntityAssociation($this->name, $mapping['fieldName']);
  1532.             }
  1533.         }
  1535.         // Mandatory attributes for both sides
  1536.         // Mandatory: fieldName, targetEntity
  1537.         if ( ! isset($mapping['fieldName']) || !$mapping['fieldName']) {
  1538.             throw MappingException::missingFieldName($this->name);
  1539.         }
  1541.         if ( ! isset($mapping['targetEntity'])) {
  1542.             throw MappingException::missingTargetEntity($mapping['fieldName']);
  1543.         }
  1545.         // Mandatory and optional attributes for either side
  1546.         if ( ! $mapping['mappedBy']) {
  1547.             if (isset($mapping['joinTable']) && $mapping['joinTable']) {
  1548.                 if (isset($mapping['joinTable']['name']) && $mapping['joinTable']['name'][0] === '`') {
  1549.                     $mapping['joinTable']['name']   = trim($mapping['joinTable']['name'], '`');
  1550.                     $mapping['joinTable']['quoted'] = true;
  1551.                 }
  1552.             }
  1553.         } else {
  1554.             $mapping['isOwningSide'] = false;
  1555.         }
  1557.         if (isset($mapping['id']) && true === $mapping['id'] && $mapping['type'] & self::TO_MANY) {
  1558.             throw MappingException::illegalToManyIdentifierAssociation($this->name, $mapping['fieldName']);
  1559.         }
  1561.         // Fetch mode. Default fetch mode to LAZY, if not set.
  1562.         if ( ! isset($mapping['fetch'])) {
  1563.             $mapping['fetch'] = self::FETCH_LAZY;
  1564.         }
  1566.         // Cascades
  1567.         $cascades = isset($mapping['cascade']) ? array_map('strtolower', $mapping['cascade']) : [];
  1569.         $allCascades = ['remove', 'persist', 'refresh', 'merge', 'detach'];
  1570.         if (in_array('all', $cascades)) {
  1571.             $cascades = $allCascades;
  1572.         } elseif (count($cascades) !== count(array_intersect($cascades, $allCascades))) {
  1573.             throw MappingException::invalidCascadeOption(
  1574.                 array_diff($cascades, $allCascades),
  1575.                 $this->name,
  1576.                 $mapping['fieldName']
  1577.             );
  1578.         }
  1580.         $mapping['cascade'] = $cascades;
  1581.         $mapping['isCascadeRemove']  = in_array('remove', $cascades);
  1582.         $mapping['isCascadePersist'] = in_array('persist', $cascades);
  1583.         $mapping['isCascadeRefresh'] = in_array('refresh', $cascades);
  1584.         $mapping['isCascadeMerge']   = in_array('merge', $cascades);
  1585.         $mapping['isCascadeDetach']  = in_array('detach', $cascades);
  1587.         return $mapping;
  1588.     }
  1590.     /**
  1591.      * Validates & completes a one-to-one association mapping.
  1592.      *
  1593.      * @param array $mapping The mapping to validate & complete.
  1594.      *
  1595.      * @return mixed[] The validated & completed mapping.
  1596.      *
  1597.      * @throws RuntimeException
  1598.      * @throws MappingException
  1599.      *
  1600.      * @psalm-return array{isOwningSide: mixed, orphanRemoval: bool, isCascadeRemove: bool}
  1601.      */
  1602.     protected function _validateAndCompleteOneToOneMapping(array $mapping)
  1603.     {
  1604.         $mapping = $this->_validateAndCompleteAssociationMapping($mapping);
  1606.         if (isset($mapping['joinColumns']) && $mapping['joinColumns']) {
  1607.             $mapping['isOwningSide'] = true;
  1608.         }
  1610.         if ($mapping['isOwningSide']) {
  1611.             if (empty($mapping['joinColumns'])) {
  1612.                 // Apply default join column
  1613.                 $mapping['joinColumns'] = [
  1614.                     [
  1615.                         'name' => $this->namingStrategy->joinColumnName($mapping['fieldName'], $this->name),
  1616.                         'referencedColumnName' => $this->namingStrategy->referenceColumnName()
  1617.                     ]
  1618.                 ];
  1619.             }
  1621.             $uniqueConstraintColumns = [];
  1623.             foreach ($mapping['joinColumns'] as &$joinColumn) {
  1624.                 if ($mapping['type'] === self::ONE_TO_ONE && ! $this->isInheritanceTypeSingleTable()) {
  1625.                     if (count($mapping['joinColumns']) === 1) {
  1626.                         if (empty($mapping['id'])) {
  1627.                             $joinColumn['unique'] = true;
  1628.                         }
  1629.                     } else {
  1630.                         $uniqueConstraintColumns[] = $joinColumn['name'];
  1631.                     }
  1632.                 }
  1634.                 if (empty($joinColumn['name'])) {
  1635.                     $joinColumn['name'] = $this->namingStrategy->joinColumnName($mapping['fieldName'], $this->name);
  1636.                 }
  1638.                 if (empty($joinColumn['referencedColumnName'])) {
  1639.                     $joinColumn['referencedColumnName'] = $this->namingStrategy->referenceColumnName();
  1640.                 }
  1642.                 if ($joinColumn['name'][0] === '`') {
  1643.                     $joinColumn['name']   = trim($joinColumn['name'], '`');
  1644.                     $joinColumn['quoted'] = true;
  1645.                 }
  1647.                 if ($joinColumn['referencedColumnName'][0] === '`') {
  1648.                     $joinColumn['referencedColumnName'] = trim($joinColumn['referencedColumnName'], '`');
  1649.                     $joinColumn['quoted']               = true;
  1650.                 }
  1652.                 $mapping['sourceToTargetKeyColumns'][$joinColumn['name']] = $joinColumn['referencedColumnName'];
  1653.                 $mapping['joinColumnFieldNames'][$joinColumn['name']] = $joinColumn['fieldName'] ?? $joinColumn['name'];
  1654.             }
  1656.             if ($uniqueConstraintColumns) {
  1657.                 if ( ! $this->table) {
  1658.                     throw new RuntimeException("ClassMetadataInfo::setTable() has to be called before defining a one to one relationship.");
  1659.                 }
  1661.                 $this->table['uniqueConstraints'][$mapping['fieldName'] . "_uniq"] = [
  1662.                     'columns' => $uniqueConstraintColumns
  1663.                 ];
  1664.             }
  1666.             $mapping['targetToSourceKeyColumns'] = array_flip($mapping['sourceToTargetKeyColumns']);
  1667.         }
  1669.         $mapping['orphanRemoval']   = isset($mapping['orphanRemoval']) && $mapping['orphanRemoval'];
  1670.         $mapping['isCascadeRemove'] = $mapping['orphanRemoval'] || $mapping['isCascadeRemove'];
  1672.         if ($mapping['orphanRemoval']) {
  1673.             unset($mapping['unique']);
  1674.         }
  1676.         if (isset($mapping['id']) && $mapping['id'] === true && !$mapping['isOwningSide']) {
  1677.             throw MappingException::illegalInverseIdentifierAssociation($this->name, $mapping['fieldName']);
  1678.         }
  1680.         return $mapping;
  1681.     }
  1683.     /**
  1684.      * Validates & completes a one-to-many association mapping.
  1685.      *
  1686.      * @param array $mapping The mapping to validate and complete.
  1687.      *
  1688.      * @return mixed[] The validated and completed mapping.
  1689.      *
  1690.      * @throws MappingException
  1691.      * @throws InvalidArgumentException
  1692.      *
  1693.      * @psalm-return array{
  1694.      *                   mappedBy: mixed,
  1695.      *                   inversedBy: mixed,
  1696.      *                   isOwningSide: bool,
  1697.      *                   sourceEntity: string,
  1698.      *                   targetEntity: string,
  1699.      *                   fieldName: mixed,
  1700.      *                   fetch: int|mixed,
  1701.      *                   cascade: array<array-key,string>,
  1702.      *                   isCascadeRemove: bool,
  1703.      *                   isCascadePersist: bool,
  1704.      *                   isCascadeRefresh: bool,
  1705.      *                   isCascadeMerge: bool,
  1706.      *                   isCascadeDetach: bool,
  1707.      *                   orphanRemoval: bool
  1708.      *               }
  1709.      */
  1710.     protected function _validateAndCompleteOneToManyMapping(array $mapping)
  1711.     {
  1712.         $mapping = $this->_validateAndCompleteAssociationMapping($mapping);
  1714.         // OneToMany-side MUST be inverse (must have mappedBy)
  1715.         if ( ! isset($mapping['mappedBy'])) {
  1716.             throw MappingException::oneToManyRequiresMappedBy($mapping['fieldName']);
  1717.         }
  1719.         $mapping['orphanRemoval']   = isset($mapping['orphanRemoval']) && $mapping['orphanRemoval'];
  1720.         $mapping['isCascadeRemove'] = $mapping['orphanRemoval'] || $mapping['isCascadeRemove'];
  1722.         $this->assertMappingOrderBy($mapping);
  1724.         return $mapping;
  1725.     }
  1727.     /**
  1728.      * Validates & completes a many-to-many association mapping.
  1729.      *
  1730.      * @param array $mapping The mapping to validate & complete.
  1731.      *
  1732.      * @return mixed[] The validated & completed mapping.
  1733.      *
  1734.      * @throws \InvalidArgumentException
  1735.      *
  1736.      * @psalm-return array{isOwningSide: mixed, orphanRemoval: bool}
  1737.      */
  1738.     protected function _validateAndCompleteManyToManyMapping(array $mapping)
  1739.     {
  1740.         $mapping = $this->_validateAndCompleteAssociationMapping($mapping);
  1742.         if ($mapping['isOwningSide']) {
  1743.             // owning side MUST have a join table
  1744.             if ( ! isset($mapping['joinTable']['name'])) {
  1745.                 $mapping['joinTable']['name'] = $this->namingStrategy->joinTableName($mapping['sourceEntity'], $mapping['targetEntity'], $mapping['fieldName']);
  1746.             }
  1748.             $selfReferencingEntityWithoutJoinColumns = $mapping['sourceEntity'] == $mapping['targetEntity']
  1749.                 && (! (isset($mapping['joinTable']['joinColumns']) || isset($mapping['joinTable']['inverseJoinColumns'])));
  1751.             if ( ! isset($mapping['joinTable']['joinColumns'])) {
  1752.                 $mapping['joinTable']['joinColumns'] = [
  1753.                     [
  1754.                         'name' => $this->namingStrategy->joinKeyColumnName($mapping['sourceEntity'], $selfReferencingEntityWithoutJoinColumns ? 'source' : null),
  1755.                         'referencedColumnName' => $this->namingStrategy->referenceColumnName(),
  1756.                         'onDelete' => 'CASCADE'
  1757.                     ]
  1758.                 ];
  1759.             }
  1761.             if ( ! isset($mapping['joinTable']['inverseJoinColumns'])) {
  1762.                 $mapping['joinTable']['inverseJoinColumns'] = [
  1763.                     [
  1764.                         'name' => $this->namingStrategy->joinKeyColumnName($mapping['targetEntity'], $selfReferencingEntityWithoutJoinColumns ? 'target' : null),
  1765.                         'referencedColumnName' => $this->namingStrategy->referenceColumnName(),
  1766.                         'onDelete' => 'CASCADE'
  1767.                     ]
  1768.                 ];
  1769.             }
  1771.             $mapping['joinTableColumns'] = [];
  1773.             foreach ($mapping['joinTable']['joinColumns'] as &$joinColumn) {
  1774.                 if (empty($joinColumn['name'])) {
  1775.                     $joinColumn['name'] = $this->namingStrategy->joinKeyColumnName($mapping['sourceEntity'], $joinColumn['referencedColumnName']);
  1776.                 }
  1778.                 if (empty($joinColumn['referencedColumnName'])) {
  1779.                     $joinColumn['referencedColumnName'] = $this->namingStrategy->referenceColumnName();
  1780.                 }
  1782.                 if ($joinColumn['name'][0] === '`') {
  1783.                     $joinColumn['name']   = trim($joinColumn['name'], '`');
  1784.                     $joinColumn['quoted'] = true;
  1785.                 }
  1787.                 if ($joinColumn['referencedColumnName'][0] === '`') {
  1788.                     $joinColumn['referencedColumnName'] = trim($joinColumn['referencedColumnName'], '`');
  1789.                     $joinColumn['quoted']               = true;
  1790.                 }
  1792.                 if (isset($joinColumn['onDelete']) && strtolower($joinColumn['onDelete']) == 'cascade') {
  1793.                     $mapping['isOnDeleteCascade'] = true;
  1794.                 }
  1796.                 $mapping['relationToSourceKeyColumns'][$joinColumn['name']] = $joinColumn['referencedColumnName'];
  1797.                 $mapping['joinTableColumns'][] = $joinColumn['name'];
  1798.             }
  1800.             foreach ($mapping['joinTable']['inverseJoinColumns'] as &$inverseJoinColumn) {
  1801.                 if (empty($inverseJoinColumn['name'])) {
  1802.                     $inverseJoinColumn['name'] = $this->namingStrategy->joinKeyColumnName($mapping['targetEntity'], $inverseJoinColumn['referencedColumnName']);
  1803.                 }
  1805.                 if (empty($inverseJoinColumn['referencedColumnName'])) {
  1806.                     $inverseJoinColumn['referencedColumnName'] = $this->namingStrategy->referenceColumnName();
  1807.                 }
  1809.                 if ($inverseJoinColumn['name'][0] === '`') {
  1810.                     $inverseJoinColumn['name']   = trim($inverseJoinColumn['name'], '`');
  1811.                     $inverseJoinColumn['quoted'] = true;
  1812.                 }
  1814.                 if ($inverseJoinColumn['referencedColumnName'][0] === '`') {
  1815.                     $inverseJoinColumn['referencedColumnName']  = trim($inverseJoinColumn['referencedColumnName'], '`');
  1816.                     $inverseJoinColumn['quoted']                = true;
  1817.                 }
  1819.                 if (isset($inverseJoinColumn['onDelete']) && strtolower($inverseJoinColumn['onDelete']) == 'cascade') {
  1820.                     $mapping['isOnDeleteCascade'] = true;
  1821.                 }
  1823.                 $mapping['relationToTargetKeyColumns'][$inverseJoinColumn['name']] = $inverseJoinColumn['referencedColumnName'];
  1824.                 $mapping['joinTableColumns'][] = $inverseJoinColumn['name'];
  1825.             }
  1826.         }
  1828.         $mapping['orphanRemoval'] = isset($mapping['orphanRemoval']) && $mapping['orphanRemoval'];
  1830.         $this->assertMappingOrderBy($mapping);
  1832.         return $mapping;
  1833.     }
  1835.     /**
  1836.      * {@inheritDoc}
  1837.      */
  1838.     public function getIdentifierFieldNames()
  1839.     {
  1840.         return $this->identifier;
  1841.     }
  1843.     /**
  1844.      * Gets the name of the single id field. Note that this only works on
  1845.      * entity classes that have a single-field pk.
  1846.      *
  1847.      * @return string
  1848.      *
  1849.      * @throws MappingException If the class doesn't have an identifier or it has a composite primary key.
  1850.      */
  1851.     public function getSingleIdentifierFieldName()
  1852.     {
  1853.         if ($this->isIdentifierComposite) {
  1854.             throw MappingException::singleIdNotAllowedOnCompositePrimaryKey($this->name);
  1855.         }
  1857.         if ( ! isset($this->identifier[0])) {
  1858.             throw MappingException::noIdDefined($this->name);
  1859.         }
  1861.         return $this->identifier[0];
  1862.     }
  1864.     /**
  1865.      * Gets the column name of the single id column. Note that this only works on
  1866.      * entity classes that have a single-field pk.
  1867.      *
  1868.      * @return string
  1869.      *
  1870.      * @throws MappingException If the class doesn't have an identifier or it has a composite primary key.
  1871.      */
  1872.     public function getSingleIdentifierColumnName()
  1873.     {
  1874.         return $this->getColumnName($this->getSingleIdentifierFieldName());
  1875.     }
  1877.     /**
  1878.      * INTERNAL:
  1879.      * Sets the mapped identifier/primary key fields of this class.
  1880.      * Mainly used by the ClassMetadataFactory to assign inherited identifiers.
  1881.      *
  1882.      * @param array $identifier
  1883.      *
  1884.      * @return void
  1885.      */
  1886.     public function setIdentifier(array $identifier)
  1887.     {
  1888.         $this->identifier = $identifier;
  1889.         $this->isIdentifierComposite = (count($this->identifier) > 1);
  1890.     }
  1892.     /**
  1893.      * {@inheritDoc}
  1894.      */
  1895.     public function getIdentifier()
  1896.     {
  1897.         return $this->identifier;
  1898.     }
  1900.     /**
  1901.      * {@inheritDoc}
  1902.      */
  1903.     public function hasField($fieldName)
  1904.     {
  1905.         return isset($this->fieldMappings[$fieldName]) || isset($this->embeddedClasses[$fieldName]);
  1906.     }
  1908.     /**
  1909.      * Gets an array containing all the column names.
  1910.      *
  1911.      * @param array|null $fieldNames
  1912.      *
  1913.      * @return mixed[]
  1914.      *
  1915.      * @psalm-return list<string>
  1916.      */
  1917.     public function getColumnNames(array $fieldNames = null)
  1918.     {
  1919.         if (null === $fieldNames) {
  1920.             return array_keys($this->fieldNames);
  1921.         }
  1923.         return array_values(array_map([$this, 'getColumnName'], $fieldNames));
  1924.     }
  1926.     /**
  1927.      * Returns an array with all the identifier column names.
  1928.      *
  1929.      * @return array
  1930.      */
  1931.     public function getIdentifierColumnNames()
  1932.     {
  1933.         $columnNames = [];
  1935.         foreach ($this->identifier as $idProperty) {
  1936.             if (isset($this->fieldMappings[$idProperty])) {
  1937.                 $columnNames[] = $this->fieldMappings[$idProperty]['columnName'];
  1939.                 continue;
  1940.             }
  1942.             // Association defined as Id field
  1943.             $joinColumns      = $this->associationMappings[$idProperty]['joinColumns'];
  1944.             $assocColumnNames = array_map(function ($joinColumn) { return $joinColumn['name']; }, $joinColumns);
  1946.             $columnNames = array_merge($columnNames, $assocColumnNames);
  1947.         }
  1949.         return $columnNames;
  1950.     }
  1952.     /**
  1953.      * Sets the type of Id generator to use for the mapped class.
  1954.      *
  1955.      * @param int $generatorType
  1956.      *
  1957.      * @return void
  1958.      */
  1959.     public function setIdGeneratorType($generatorType)
  1960.     {
  1961.         $this->generatorType = $generatorType;
  1962.     }
  1964.     /**
  1965.      * Checks whether the mapped class uses an Id generator.
  1966.      *
  1967.      * @return boolean TRUE if the mapped class uses an Id generator, FALSE otherwise.
  1968.      */
  1969.     public function usesIdGenerator()
  1970.     {
  1971.         return $this->generatorType != self::GENERATOR_TYPE_NONE;
  1972.     }
  1974.     /**
  1975.      * @return boolean
  1976.      */
  1977.     public function isInheritanceTypeNone()
  1978.     {
  1979.         return $this->inheritanceType == self::INHERITANCE_TYPE_NONE;
  1980.     }
  1982.     /**
  1983.      * Checks whether the mapped class uses the JOINED inheritance mapping strategy.
  1984.      *
  1985.      * @return boolean TRUE if the class participates in a JOINED inheritance mapping,
  1986.      *                 FALSE otherwise.
  1987.      */
  1988.     public function isInheritanceTypeJoined()
  1989.     {
  1990.         return $this->inheritanceType == self::INHERITANCE_TYPE_JOINED;
  1991.     }
  1993.     /**
  1994.      * Checks whether the mapped class uses the SINGLE_TABLE inheritance mapping strategy.
  1995.      *
  1996.      * @return boolean TRUE if the class participates in a SINGLE_TABLE inheritance mapping,
  1997.      *                 FALSE otherwise.
  1998.      */
  1999.     public function isInheritanceTypeSingleTable()
  2000.     {
  2001.         return $this->inheritanceType == self::INHERITANCE_TYPE_SINGLE_TABLE;
  2002.     }
  2004.     /**
  2005.      * Checks whether the mapped class uses the TABLE_PER_CLASS inheritance mapping strategy.
  2006.      *
  2007.      * @return boolean TRUE if the class participates in a TABLE_PER_CLASS inheritance mapping,
  2008.      *                 FALSE otherwise.
  2009.      */
  2010.     public function isInheritanceTypeTablePerClass()
  2011.     {
  2012.         return $this->inheritanceType == self::INHERITANCE_TYPE_TABLE_PER_CLASS;
  2013.     }
  2015.     /**
  2016.      * Checks whether the class uses an identity column for the Id generation.
  2017.      *
  2018.      * @return boolean TRUE if the class uses the IDENTITY generator, FALSE otherwise.
  2019.      */
  2020.     public function isIdGeneratorIdentity()
  2021.     {
  2022.         return $this->generatorType == self::GENERATOR_TYPE_IDENTITY;
  2023.     }
  2025.     /**
  2026.      * Checks whether the class uses a sequence for id generation.
  2027.      *
  2028.      * @return boolean TRUE if the class uses the SEQUENCE generator, FALSE otherwise.
  2029.      */
  2030.     public function isIdGeneratorSequence()
  2031.     {
  2032.         return $this->generatorType == self::GENERATOR_TYPE_SEQUENCE;
  2033.     }
  2035.     /**
  2036.      * Checks whether the class uses a table for id generation.
  2037.      *
  2038.      * @return boolean TRUE if the class uses the TABLE generator, FALSE otherwise.
  2039.      */
  2040.     public function isIdGeneratorTable()
  2041.     {
  2042.         return $this->generatorType == self::GENERATOR_TYPE_TABLE;
  2043.     }
  2045.     /**
  2046.      * Checks whether the class has a natural identifier/pk (which means it does
  2047.      * not use any Id generator.
  2048.      *
  2049.      * @return boolean
  2050.      */
  2051.     public function isIdentifierNatural()
  2052.     {
  2053.         return $this->generatorType == self::GENERATOR_TYPE_NONE;
  2054.     }
  2056.     /**
  2057.      * Checks whether the class use a UUID for id generation.
  2058.      *
  2059.      * @return boolean
  2060.      */
  2061.     public function isIdentifierUuid()
  2062.     {
  2063.         return $this->generatorType == self::GENERATOR_TYPE_UUID;
  2064.     }
  2066.     /**
  2067.      * Gets the type of a field.
  2068.      *
  2069.      * @param string $fieldName
  2070.      *
  2071.      * @return string|null
  2072.      *
  2073.      * @todo 3.0 Remove this. PersisterHelper should fix it somehow
  2074.      */
  2075.     public function getTypeOfField($fieldName)
  2076.     {
  2077.         return isset($this->fieldMappings[$fieldName])
  2078.             ? $this->fieldMappings[$fieldName]['type']
  2079.             : null;
  2080.     }
  2082.     /**
  2083.      * Gets the type of a column.
  2084.      *
  2085.      * @param string $columnName
  2086.      *
  2087.      * @return string|null
  2088.      *
  2089.      * @deprecated 3.0 remove this. this method is bogus and unreliable, since it cannot resolve the type of a column
  2090.      *             that is derived by a referenced field on a different entity.
  2091.      */
  2092.     public function getTypeOfColumn($columnName)
  2093.     {
  2094.         return $this->getTypeOfField($this->getFieldName($columnName));
  2095.     }
  2097.     /**
  2098.      * Gets the name of the primary table.
  2099.      *
  2100.      * @return string
  2101.      */
  2102.     public function getTableName()
  2103.     {
  2104.         return $this->table['name'];
  2105.     }
  2107.     /**
  2108.      * Gets primary table's schema name.
  2109.      *
  2110.      * @return string|null
  2111.      */
  2112.     public function getSchemaName()
  2113.     {
  2114.         return isset($this->table['schema']) ? $this->table['schema'] : null;
  2115.     }
  2117.     /**
  2118.      * Gets the table name to use for temporary identifier tables of this class.
  2119.      *
  2120.      * @return string
  2121.      */
  2122.     public function getTemporaryIdTableName()
  2123.     {
  2124.         // replace dots with underscores because PostgreSQL creates temporary tables in a special schema
  2125.         return str_replace('.', '_', $this->getTableName() . '_id_tmp');
  2126.     }
  2128.     /**
  2129.      * Sets the mapped subclasses of this class.
  2130.      *
  2131.      * @param array $subclasses The names of all mapped subclasses.
  2132.      *
  2133.      * @return void
  2134.      */
  2135.     public function setSubclasses(array $subclasses)
  2136.     {
  2137.         foreach ($subclasses as $subclass) {
  2138.             $this->subClasses[] = $this->fullyQualifiedClassName($subclass);
  2139.         }
  2140.     }
  2142.     /**
  2143.      * Sets the parent class names.
  2144.      * Assumes that the class names in the passed array are in the order:
  2145.      * directParent -> directParentParent -> directParentParentParent ... -> root.
  2146.      *
  2147.      * @param array $classNames
  2148.      *
  2149.      * @return void
  2150.      */
  2151.     public function setParentClasses(array $classNames)
  2152.     {
  2153.         $this->parentClasses = $classNames;
  2155.         if (count($classNames) > 0) {
  2156.             $this->rootEntityName = array_pop($classNames);
  2157.         }
  2158.     }
  2160.     /**
  2161.      * Sets the inheritance type used by the class and its subclasses.
  2162.      *
  2163.      * @param integer $type
  2164.      *
  2165.      * @return void
  2166.      *
  2167.      * @throws MappingException
  2168.      */
  2169.     public function setInheritanceType($type)
  2170.     {
  2171.         if ( ! $this->_isInheritanceType($type)) {
  2172.             throw MappingException::invalidInheritanceType($this->name, $type);
  2173.         }
  2175.         $this->inheritanceType = $type;
  2176.     }
  2178.     /**
  2179.      * Sets the association to override association mapping of property for an entity relationship.
  2180.      *
  2181.      * @param string $fieldName
  2182.      * @param array  $overrideMapping
  2183.      *
  2184.      * @return void
  2185.      *
  2186.      * @throws MappingException
  2187.      */
  2188.     public function setAssociationOverride($fieldName, array $overrideMapping)
  2189.     {
  2190.         if ( ! isset($this->associationMappings[$fieldName])) {
  2191.             throw MappingException::invalidOverrideFieldName($this->name, $fieldName);
  2192.         }
  2194.         $mapping = $this->associationMappings[$fieldName];
  2196.         //if (isset($mapping['inherited']) && (count($overrideMapping) !== 1 || ! isset($overrideMapping['fetch']))) {
  2197.             // TODO: Deprecate overriding the fetch mode via association override for 3.0,
  2198.             // users should do this with a listener and a custom attribute/annotation
  2199.             // TODO: Enable this exception in 2.8
  2200.             //throw MappingException::illegalOverrideOfInheritedProperty($this->name, $fieldName);
  2201.         //}
  2203.         if (isset($overrideMapping['joinColumns'])) {
  2204.             $mapping['joinColumns'] = $overrideMapping['joinColumns'];
  2205.         }
  2207.         if (isset($overrideMapping['inversedBy'])) {
  2208.             $mapping['inversedBy'] = $overrideMapping['inversedBy'];
  2209.         }
  2211.         if (isset($overrideMapping['joinTable'])) {
  2212.             $mapping['joinTable'] = $overrideMapping['joinTable'];
  2213.         }
  2215.         if (isset($overrideMapping['fetch'])) {
  2216.             $mapping['fetch'] = $overrideMapping['fetch'];
  2217.         }
  2219.         $mapping['joinColumnFieldNames']        = null;
  2220.         $mapping['joinTableColumns']            = null;
  2221.         $mapping['sourceToTargetKeyColumns']    = null;
  2222.         $mapping['relationToSourceKeyColumns']  = null;
  2223.         $mapping['relationToTargetKeyColumns']  = null;
  2225.         switch ($mapping['type']) {
  2226.             case self::ONE_TO_ONE:
  2227.                 $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
  2228.                 break;
  2229.             case self::ONE_TO_MANY:
  2230.                 $mapping = $this->_validateAndCompleteOneToManyMapping($mapping);
  2231.                 break;
  2232.             case self::MANY_TO_ONE:
  2233.                 $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
  2234.                 break;
  2235.             case self::MANY_TO_MANY:
  2236.                 $mapping = $this->_validateAndCompleteManyToManyMapping($mapping);
  2237.                 break;
  2238.         }
  2240.         $this->associationMappings[$fieldName] = $mapping;
  2241.     }
  2243.     /**
  2244.      * Sets the override for a mapped field.
  2245.      *
  2246.      * @param string $fieldName
  2247.      * @param array  $overrideMapping
  2248.      *
  2249.      * @return void
  2250.      *
  2251.      * @throws MappingException
  2252.      */
  2253.     public function setAttributeOverride($fieldName, array $overrideMapping)
  2254.     {
  2255.         if ( ! isset($this->fieldMappings[$fieldName])) {
  2256.             throw MappingException::invalidOverrideFieldName($this->name, $fieldName);
  2257.         }
  2259.         $mapping = $this->fieldMappings[$fieldName];
  2261.         //if (isset($mapping['inherited'])) {
  2262.             // TODO: Enable this exception in 2.8
  2263.             //throw MappingException::illegalOverrideOfInheritedProperty($this->name, $fieldName);
  2264.         //}
  2266.         if (isset($mapping['id'])) {
  2267.             $overrideMapping['id'] = $mapping['id'];
  2268.         }
  2270.         if ( ! isset($overrideMapping['type'])) {
  2271.             $overrideMapping['type'] = $mapping['type'];
  2272.         }
  2274.         if ( ! isset($overrideMapping['fieldName'])) {
  2275.             $overrideMapping['fieldName'] = $mapping['fieldName'];
  2276.         }
  2278.         if ($overrideMapping['type'] !== $mapping['type']) {
  2279.             throw MappingException::invalidOverrideFieldType($this->name, $fieldName);
  2280.         }
  2282.         unset($this->fieldMappings[$fieldName]);
  2283.         unset($this->fieldNames[$mapping['columnName']]);
  2284.         unset($this->columnNames[$mapping['fieldName']]);
  2286.         $this->_validateAndCompleteFieldMapping($overrideMapping);
  2288.         $this->fieldMappings[$fieldName] = $overrideMapping;
  2289.     }
  2291.     /**
  2292.      * Checks whether a mapped field is inherited from an entity superclass.
  2293.      *
  2294.      * @param string $fieldName
  2295.      *
  2296.      * @return bool TRUE if the field is inherited, FALSE otherwise.
  2297.      */
  2298.     public function isInheritedField($fieldName)
  2299.     {
  2300.         return isset($this->fieldMappings[$fieldName]['inherited']);
  2301.     }
  2303.     /**
  2304.      * Checks if this entity is the root in any entity-inheritance-hierarchy.
  2305.      *
  2306.      * @return bool
  2307.      */
  2308.     public function isRootEntity()
  2309.     {
  2310.         return $this->name == $this->rootEntityName;
  2311.     }
  2313.     /**
  2314.      * Checks whether a mapped association field is inherited from a superclass.
  2315.      *
  2316.      * @param string $fieldName
  2317.      *
  2318.      * @return boolean TRUE if the field is inherited, FALSE otherwise.
  2319.      */
  2320.     public function isInheritedAssociation($fieldName)
  2321.     {
  2322.         return isset($this->associationMappings[$fieldName]['inherited']);
  2323.     }
  2325.     public function isInheritedEmbeddedClass($fieldName)
  2326.     {
  2327.         return isset($this->embeddedClasses[$fieldName]['inherited']);
  2328.     }
  2330.     /**
  2331.      * Sets the name of the primary table the class is mapped to.
  2332.      *
  2333.      * @param string $tableName The table name.
  2334.      *
  2335.      * @return void
  2336.      *
  2337.      * @deprecated Use {@link setPrimaryTable}.
  2338.      */
  2339.     public function setTableName($tableName)
  2340.     {
  2341.         $this->table['name'] = $tableName;
  2342.     }
  2344.     /**
  2345.      * Sets the primary table definition. The provided array supports the
  2346.      * following structure:
  2347.      *
  2348.      * name => <tableName> (optional, defaults to class name)
  2349.      * indexes => array of indexes (optional)
  2350.      * uniqueConstraints => array of constraints (optional)
  2351.      *
  2352.      * If a key is omitted, the current value is kept.
  2353.      *
  2354.      * @param array $table The table description.
  2355.      *
  2356.      * @return void
  2357.      */
  2358.     public function setPrimaryTable(array $table)
  2359.     {
  2360.         if (isset($table['name'])) {
  2361.             // Split schema and table name from a table name like "myschema.mytable"
  2362.             if (strpos($table['name'], '.') !== false) {
  2363.                 [$this->table['schema'], $table['name']] = explode('.', $table['name'], 2);
  2364.             }
  2366.             if ($table['name'][0] === '`') {
  2367.                 $table['name']          = trim($table['name'], '`');
  2368.                 $this->table['quoted']  = true;
  2369.             }
  2371.             $this->table['name'] = $table['name'];
  2372.         }
  2374.         if (isset($table['quoted'])) {
  2375.             $this->table['quoted'] = $table['quoted'];
  2376.         }
  2378.         if (isset($table['schema'])) {
  2379.             $this->table['schema'] = $table['schema'];
  2380.         }
  2382.         if (isset($table['indexes'])) {
  2383.             $this->table['indexes'] = $table['indexes'];
  2384.         }
  2386.         if (isset($table['uniqueConstraints'])) {
  2387.             $this->table['uniqueConstraints'] = $table['uniqueConstraints'];
  2388.         }
  2390.         if (isset($table['options'])) {
  2391.             $this->table['options'] = $table['options'];
  2392.         }
  2393.     }
  2395.     /**
  2396.      * Checks whether the given type identifies an inheritance type.
  2397.      *
  2398.      * @param integer $type
  2399.      *
  2400.      * @return boolean TRUE if the given type identifies an inheritance type, FALSe otherwise.
  2401.      */
  2402.     private function _isInheritanceType($type)
  2403.     {
  2404.         return $type == self::INHERITANCE_TYPE_NONE ||
  2405.                 $type == self::INHERITANCE_TYPE_SINGLE_TABLE ||
  2406.                 $type == self::INHERITANCE_TYPE_JOINED ||
  2407.                 $type == self::INHERITANCE_TYPE_TABLE_PER_CLASS;
  2408.     }
  2410.     /**
  2411.      * Adds a mapped field to the class.
  2412.      *
  2413.      * @param array $mapping The field mapping.
  2414.      *
  2415.      * @return void
  2416.      *
  2417.      * @throws MappingException
  2418.      */
  2419.     public function mapField(array $mapping)
  2420.     {
  2421.         $this->_validateAndCompleteFieldMapping($mapping);
  2422.         $this->assertFieldNotMapped($mapping['fieldName']);
  2424.         $this->fieldMappings[$mapping['fieldName']] = $mapping;
  2425.     }
  2427.     /**
  2428.      * INTERNAL:
  2429.      * Adds an association mapping without completing/validating it.
  2430.      * This is mainly used to add inherited association mappings to derived classes.
  2431.      *
  2432.      * @param array $mapping
  2433.      *
  2434.      * @return void
  2435.      *
  2436.      * @throws MappingException
  2437.      */
  2438.     public function addInheritedAssociationMapping(array $mapping/*, $owningClassName = null*/)
  2439.     {
  2440.         if (isset($this->associationMappings[$mapping['fieldName']])) {
  2441.             throw MappingException::duplicateAssociationMapping($this->name, $mapping['fieldName']);
  2442.         }
  2443.         $this->associationMappings[$mapping['fieldName']] = $mapping;
  2444.     }
  2446.     /**
  2447.      * INTERNAL:
  2448.      * Adds a field mapping without completing/validating it.
  2449.      * This is mainly used to add inherited field mappings to derived classes.
  2450.      *
  2451.      * @param array $fieldMapping
  2452.      *
  2453.      * @return void
  2454.      */
  2455.     public function addInheritedFieldMapping(array $fieldMapping)
  2456.     {
  2457.         $this->fieldMappings[$fieldMapping['fieldName']] = $fieldMapping;
  2458.         $this->columnNames[$fieldMapping['fieldName']] = $fieldMapping['columnName'];
  2459.         $this->fieldNames[$fieldMapping['columnName']] = $fieldMapping['fieldName'];
  2460.     }
  2462.     /**
  2463.      * INTERNAL:
  2464.      * Adds a named query to this class.
  2465.      *
  2466.      * @param array $queryMapping
  2467.      *
  2468.      * @return void
  2469.      *
  2470.      * @throws MappingException
  2471.      */
  2472.     public function addNamedQuery(array $queryMapping)
  2473.     {
  2474.         if (!isset($queryMapping['name'])) {
  2475.             throw MappingException::nameIsMandatoryForQueryMapping($this->name);
  2476.         }
  2478.         if (isset($this->namedQueries[$queryMapping['name']])) {
  2479.             throw MappingException::duplicateQueryMapping($this->name, $queryMapping['name']);
  2480.         }
  2482.         if (!isset($queryMapping['query'])) {
  2483.             throw MappingException::emptyQueryMapping($this->name, $queryMapping['name']);
  2484.         }
  2486.         $name   = $queryMapping['name'];
  2487.         $query  = $queryMapping['query'];
  2488.         $dql    = str_replace('__CLASS__', $this->name, $query);
  2490.         $this->namedQueries[$name] = [
  2491.             'name'  => $name,
  2492.             'query' => $query,
  2493.             'dql'   => $dql,
  2494.         ];
  2495.     }
  2497.     /**
  2498.      * INTERNAL:
  2499.      * Adds a named native query to this class.
  2500.      *
  2501.      * @param array $queryMapping
  2502.      *
  2503.      * @return void
  2504.      *
  2505.      * @throws MappingException
  2506.      */
  2507.     public function addNamedNativeQuery(array $queryMapping)
  2508.     {
  2509.         if (!isset($queryMapping['name'])) {
  2510.             throw MappingException::nameIsMandatoryForQueryMapping($this->name);
  2511.         }
  2513.         if (isset($this->namedNativeQueries[$queryMapping['name']])) {
  2514.             throw MappingException::duplicateQueryMapping($this->name, $queryMapping['name']);
  2515.         }
  2517.         if (!isset($queryMapping['query'])) {
  2518.             throw MappingException::emptyQueryMapping($this->name, $queryMapping['name']);
  2519.         }
  2521.         if (!isset($queryMapping['resultClass']) && !isset($queryMapping['resultSetMapping'])) {
  2522.             throw MappingException::missingQueryMapping($this->name, $queryMapping['name']);
  2523.         }
  2525.         $queryMapping['isSelfClass'] = false;
  2527.         if (isset($queryMapping['resultClass'])) {
  2528.             if ($queryMapping['resultClass'] === '__CLASS__') {
  2530.                 $queryMapping['isSelfClass'] = true;
  2531.                 $queryMapping['resultClass'] = $this->name;
  2532.             }
  2534.             $queryMapping['resultClass'] = $this->fullyQualifiedClassName($queryMapping['resultClass']);
  2535.             $queryMapping['resultClass'] = ltrim($queryMapping['resultClass'], '\\');
  2536.         }
  2538.         $this->namedNativeQueries[$queryMapping['name']] = $queryMapping;
  2539.     }
  2541.     /**
  2542.      * INTERNAL:
  2543.      * Adds a sql result set mapping to this class.
  2544.      *
  2545.      * @param array $resultMapping
  2546.      *
  2547.      * @return void
  2548.      *
  2549.      * @throws MappingException
  2550.      */
  2551.     public function addSqlResultSetMapping(array $resultMapping)
  2552.     {
  2553.         if (!isset($resultMapping['name'])) {
  2554.             throw MappingException::nameIsMandatoryForSqlResultSetMapping($this->name);
  2555.         }
  2557.         if (isset($this->sqlResultSetMappings[$resultMapping['name']])) {
  2558.             throw MappingException::duplicateResultSetMapping($this->name, $resultMapping['name']);
  2559.         }
  2561.         if (isset($resultMapping['entities'])) {
  2562.             foreach ($resultMapping['entities'] as $key => $entityResult) {
  2563.                 if (!isset($entityResult['entityClass'])) {
  2564.                     throw MappingException::missingResultSetMappingEntity($this->name, $resultMapping['name']);
  2565.                 }
  2567.                 $entityResult['isSelfClass'] = false;
  2568.                 if ($entityResult['entityClass'] === '__CLASS__') {
  2570.                     $entityResult['isSelfClass'] = true;
  2571.                     $entityResult['entityClass'] = $this->name;
  2573.                 }
  2575.                 $entityResult['entityClass'] = $this->fullyQualifiedClassName($entityResult['entityClass']);
  2577.                 $resultMapping['entities'][$key]['entityClass'] = ltrim($entityResult['entityClass'], '\\');
  2578.                 $resultMapping['entities'][$key]['isSelfClass'] = $entityResult['isSelfClass'];
  2580.                 if (isset($entityResult['fields'])) {
  2581.                     foreach ($entityResult['fields'] as $k => $field) {
  2582.                         if (!isset($field['name'])) {
  2583.                             throw MappingException::missingResultSetMappingFieldName($this->name, $resultMapping['name']);
  2584.                         }
  2586.                         if (!isset($field['column'])) {
  2587.                             $fieldName = $field['name'];
  2588.                             if (strpos($fieldName, '.')) {
  2589.                                 [, $fieldName] = explode('.', $fieldName);
  2590.                             }
  2592.                             $resultMapping['entities'][$key]['fields'][$k]['column'] = $fieldName;
  2593.                         }
  2594.                     }
  2595.                 }
  2596.             }
  2597.         }
  2599.         $this->sqlResultSetMappings[$resultMapping['name']] = $resultMapping;
  2600.     }
  2602.     /**
  2603.      * Adds a one-to-one mapping.
  2604.      *
  2605.      * @param array $mapping The mapping.
  2606.      *
  2607.      * @return void
  2608.      */
  2609.     public function mapOneToOne(array $mapping)
  2610.     {
  2611.         $mapping['type'] = self::ONE_TO_ONE;
  2613.         $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
  2615.         $this->_storeAssociationMapping($mapping);
  2616.     }
  2618.     /**
  2619.      * Adds a one-to-many mapping.
  2620.      *
  2621.      * @param array $mapping The mapping.
  2622.      *
  2623.      * @return void
  2624.      */
  2625.     public function mapOneToMany(array $mapping)
  2626.     {
  2627.         $mapping['type'] = self::ONE_TO_MANY;
  2629.         $mapping = $this->_validateAndCompleteOneToManyMapping($mapping);
  2631.         $this->_storeAssociationMapping($mapping);
  2632.     }
  2634.     /**
  2635.      * Adds a many-to-one mapping.
  2636.      *
  2637.      * @param array $mapping The mapping.
  2638.      *
  2639.      * @return void
  2640.      */
  2641.     public function mapManyToOne(array $mapping)
  2642.     {
  2643.         $mapping['type'] = self::MANY_TO_ONE;
  2645.         // A many-to-one mapping is essentially a one-one backreference
  2646.         $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
  2648.         $this->_storeAssociationMapping($mapping);
  2649.     }
  2651.     /**
  2652.      * Adds a many-to-many mapping.
  2653.      *
  2654.      * @param array $mapping The mapping.
  2655.      *
  2656.      * @return void
  2657.      */
  2658.     public function mapManyToMany(array $mapping)
  2659.     {
  2660.         $mapping['type'] = self::MANY_TO_MANY;
  2662.         $mapping = $this->_validateAndCompleteManyToManyMapping($mapping);
  2664.         $this->_storeAssociationMapping($mapping);
  2665.     }
  2667.     /**
  2668.      * Stores the association mapping.
  2669.      *
  2670.      * @param array $assocMapping
  2671.      *
  2672.      * @return void
  2673.      *
  2674.      * @throws MappingException
  2675.      */
  2676.     protected function _storeAssociationMapping(array $assocMapping)
  2677.     {
  2678.         $sourceFieldName = $assocMapping['fieldName'];
  2680.         $this->assertFieldNotMapped($sourceFieldName);
  2682.         $this->associationMappings[$sourceFieldName] = $assocMapping;
  2683.     }
  2685.     /**
  2686.      * Registers a custom repository class for the entity class.
  2687.      *
  2688.      * @param string $repositoryClassName The class name of the custom mapper.
  2689.      *
  2690.      * @return void
  2691.      *
  2692.      * @psalm-param class-string $repositoryClassName
  2693.      */
  2694.     public function setCustomRepositoryClass($repositoryClassName)
  2695.     {
  2696.         $this->customRepositoryClassName = $this->fullyQualifiedClassName($repositoryClassName);
  2697.     }
  2699.     /**
  2700.      * Dispatches the lifecycle event of the given entity to the registered
  2701.      * lifecycle callbacks and lifecycle listeners.
  2702.      *
  2703.      * @deprecated Deprecated since version 2.4 in favor of \Doctrine\ORM\Event\ListenersInvoker
  2704.      *
  2705.      * @param string $lifecycleEvent The lifecycle event.
  2706.      * @param object $entity         The Entity on which the event occurred.
  2707.      *
  2708.      * @return void
  2709.      */
  2710.     public function invokeLifecycleCallbacks($lifecycleEvent, $entity)
  2711.     {
  2712.         foreach ($this->lifecycleCallbacks[$lifecycleEvent] as $callback) {
  2713.             $entity->$callback();
  2714.         }
  2715.     }
  2717.     /**
  2718.      * Whether the class has any attached lifecycle listeners or callbacks for a lifecycle event.
  2719.      *
  2720.      * @param string $lifecycleEvent
  2721.      *
  2722.      * @return boolean
  2723.      */
  2724.     public function hasLifecycleCallbacks($lifecycleEvent)
  2725.     {
  2726.         return isset($this->lifecycleCallbacks[$lifecycleEvent]);
  2727.     }
  2729.     /**
  2730.      * Gets the registered lifecycle callbacks for an event.
  2731.      *
  2732.      * @param string $event
  2733.      *
  2734.      * @return array
  2735.      */
  2736.     public function getLifecycleCallbacks($event)
  2737.     {
  2738.         return isset($this->lifecycleCallbacks[$event]) ? $this->lifecycleCallbacks[$event] : [];
  2739.     }
  2741.     /**
  2742.      * Adds a lifecycle callback for entities of this class.
  2743.      *
  2744.      * @param string $callback
  2745.      * @param string $event
  2746.      *
  2747.      * @return void
  2748.      */
  2749.     public function addLifecycleCallback($callback, $event)
  2750.     {
  2751.         if (isset($this->lifecycleCallbacks[$event]) && in_array($callback, $this->lifecycleCallbacks[$event])) {
  2752.             return;
  2753.         }
  2755.         $this->lifecycleCallbacks[$event][] = $callback;
  2756.     }
  2758.     /**
  2759.      * Sets the lifecycle callbacks for entities of this class.
  2760.      * Any previously registered callbacks are overwritten.
  2761.      *
  2762.      * @param array $callbacks
  2763.      *
  2764.      * @return void
  2765.      */
  2766.     public function setLifecycleCallbacks(array $callbacks)
  2767.     {
  2768.         $this->lifecycleCallbacks = $callbacks;
  2769.     }
  2771.     /**
  2772.      * Adds a entity listener for entities of this class.
  2773.      *
  2774.      * @param string $eventName The entity lifecycle event.
  2775.      * @param string $class     The listener class.
  2776.      * @param string $method    The listener callback method.
  2777.      *
  2778.      * @throws \Doctrine\ORM\Mapping\MappingException
  2779.      */
  2780.     public function addEntityListener($eventName, $class, $method)
  2781.     {
  2782.         $class    = $this->fullyQualifiedClassName($class);
  2784.         $listener = [
  2785.             'class'  => $class,
  2786.             'method' => $method,
  2787.         ];
  2789.         if ( ! class_exists($class)) {
  2790.             throw MappingException::entityListenerClassNotFound($class, $this->name);
  2791.         }
  2793.         if ( ! method_exists($class, $method)) {
  2794.             throw MappingException::entityListenerMethodNotFound($class, $method, $this->name);
  2795.         }
  2797.         if (isset($this->entityListeners[$eventName]) && in_array($listener, $this->entityListeners[$eventName])) {
  2798.             throw MappingException::duplicateEntityListener($class, $method, $this->name);
  2799.         }
  2801.         $this->entityListeners[$eventName][] = $listener;
  2802.     }
  2804.     /**
  2805.      * Sets the discriminator column definition.
  2806.      *
  2807.      * @param array $columnDef
  2808.      *
  2809.      * @return void
  2810.      *
  2811.      * @throws MappingException
  2812.      *
  2813.      * @see getDiscriminatorColumn()
  2814.      */
  2815.     public function setDiscriminatorColumn($columnDef)
  2816.     {
  2817.         if ($columnDef !== null) {
  2818.             if ( ! isset($columnDef['name'])) {
  2819.                 throw MappingException::nameIsMandatoryForDiscriminatorColumns($this->name);
  2820.             }
  2822.             if (isset($this->fieldNames[$columnDef['name']])) {
  2823.                 throw MappingException::duplicateColumnName($this->name, $columnDef['name']);
  2824.             }
  2826.             if ( ! isset($columnDef['fieldName'])) {
  2827.                 $columnDef['fieldName'] = $columnDef['name'];
  2828.             }
  2830.             if ( ! isset($columnDef['type'])) {
  2831.                 $columnDef['type'] = "string";
  2832.             }
  2834.             if (in_array($columnDef['type'], ["boolean", "array", "object", "datetime", "time", "date"])) {
  2835.                 throw MappingException::invalidDiscriminatorColumnType($this->name, $columnDef['type']);
  2836.             }
  2838.             $this->discriminatorColumn = $columnDef;
  2839.         }
  2840.     }
  2842.     /**
  2843.      * Sets the discriminator values used by this class.
  2844.      * Used for JOINED and SINGLE_TABLE inheritance mapping strategies.
  2845.      *
  2846.      * @param array $map
  2847.      *
  2848.      * @return void
  2849.      */
  2850.     public function setDiscriminatorMap(array $map)
  2851.     {
  2852.         foreach ($map as $value => $className) {
  2853.             $this->addDiscriminatorMapClass($value, $className);
  2854.         }
  2855.     }
  2857.     /**
  2858.      * Adds one entry of the discriminator map with a new class and corresponding name.
  2859.      *
  2860.      * @param string $name
  2861.      * @param string $className
  2862.      *
  2863.      * @return void
  2864.      *
  2865.      * @throws MappingException
  2866.      */
  2867.     public function addDiscriminatorMapClass($name, $className)
  2868.     {
  2869.         $className = $this->fullyQualifiedClassName($className);
  2870.         $className = ltrim($className, '\\');
  2872.         $this->discriminatorMap[$name] = $className;
  2874.         if ($this->name === $className) {
  2875.             $this->discriminatorValue = $name;
  2877.             return;
  2878.         }
  2880.         if ( ! (class_exists($className) || interface_exists($className))) {
  2881.             throw MappingException::invalidClassInDiscriminatorMap($className, $this->name);
  2882.         }
  2884.         if (is_subclass_of($className, $this->name) && ! in_array($className, $this->subClasses)) {
  2885.             $this->subClasses[] = $className;
  2886.         }
  2887.     }
  2889.     /**
  2890.      * Checks whether the class has a named query with the given query name.
  2891.      *
  2892.      * @param string $queryName
  2893.      *
  2894.      * @return boolean
  2895.      */
  2896.     public function hasNamedQuery($queryName)
  2897.     {
  2898.         return isset($this->namedQueries[$queryName]);
  2899.     }
  2901.     /**
  2902.      * Checks whether the class has a named native query with the given query name.
  2903.      *
  2904.      * @param string $queryName
  2905.      *
  2906.      * @return boolean
  2907.      */
  2908.     public function hasNamedNativeQuery($queryName)
  2909.     {
  2910.         return isset($this->namedNativeQueries[$queryName]);
  2911.     }
  2913.     /**
  2914.      * Checks whether the class has a named native query with the given query name.
  2915.      *
  2916.      * @param string $name
  2917.      *
  2918.      * @return boolean
  2919.      */
  2920.     public function hasSqlResultSetMapping($name)
  2921.     {
  2922.         return isset($this->sqlResultSetMappings[$name]);
  2923.     }
  2925.     /**
  2926.      * {@inheritDoc}
  2927.      */
  2928.     public function hasAssociation($fieldName)
  2929.     {
  2930.         return isset($this->associationMappings[$fieldName]);
  2931.     }
  2933.     /**
  2934.      * {@inheritDoc}
  2935.      */
  2936.     public function isSingleValuedAssociation($fieldName)
  2937.     {
  2938.         return isset($this->associationMappings[$fieldName])
  2939.             && ($this->associationMappings[$fieldName]['type'] & self::TO_ONE);
  2940.     }
  2942.     /**
  2943.      * {@inheritDoc}
  2944.      */
  2945.     public function isCollectionValuedAssociation($fieldName)
  2946.     {
  2947.         return isset($this->associationMappings[$fieldName])
  2948.             && ! ($this->associationMappings[$fieldName]['type'] & self::TO_ONE);
  2949.     }
  2951.     /**
  2952.      * Is this an association that only has a single join column?
  2953.      *
  2954.      * @param string $fieldName
  2955.      *
  2956.      * @return bool
  2957.      */
  2958.     public function isAssociationWithSingleJoinColumn($fieldName)
  2959.     {
  2960.         return isset($this->associationMappings[$fieldName])
  2961.             && isset($this->associationMappings[$fieldName]['joinColumns'][0])
  2962.             && ! isset($this->associationMappings[$fieldName]['joinColumns'][1]);
  2963.     }
  2965.     /**
  2966.      * Returns the single association join column (if any).
  2967.      *
  2968.      * @param string $fieldName
  2969.      *
  2970.      * @return string
  2971.      *
  2972.      * @throws MappingException
  2973.      */
  2974.     public function getSingleAssociationJoinColumnName($fieldName)
  2975.     {
  2976.         if ( ! $this->isAssociationWithSingleJoinColumn($fieldName)) {
  2977.             throw MappingException::noSingleAssociationJoinColumnFound($this->name, $fieldName);
  2978.         }
  2980.         return $this->associationMappings[$fieldName]['joinColumns'][0]['name'];
  2981.     }
  2983.     /**
  2984.      * Returns the single association referenced join column name (if any).
  2985.      *
  2986.      * @param string $fieldName
  2987.      *
  2988.      * @return string
  2989.      *
  2990.      * @throws MappingException
  2991.      */
  2992.     public function getSingleAssociationReferencedJoinColumnName($fieldName)
  2993.     {
  2994.         if ( ! $this->isAssociationWithSingleJoinColumn($fieldName)) {
  2995.             throw MappingException::noSingleAssociationJoinColumnFound($this->name, $fieldName);
  2996.         }
  2998.         return $this->associationMappings[$fieldName]['joinColumns'][0]['referencedColumnName'];
  2999.     }
  3001.     /**
  3002.      * Used to retrieve a fieldname for either field or association from a given column.
  3003.      *
  3004.      * This method is used in foreign-key as primary-key contexts.
  3005.      *
  3006.      * @param string $columnName
  3007.      *
  3008.      * @return string
  3009.      *
  3010.      * @throws MappingException
  3011.      */
  3012.     public function getFieldForColumn($columnName)
  3013.     {
  3014.         if (isset($this->fieldNames[$columnName])) {
  3015.             return $this->fieldNames[$columnName];
  3016.         }
  3018.         foreach ($this->associationMappings as $assocName => $mapping) {
  3019.             if ($this->isAssociationWithSingleJoinColumn($assocName) &&
  3020.                 $this->associationMappings[$assocName]['joinColumns'][0]['name'] == $columnName) {
  3022.                 return $assocName;
  3023.             }
  3024.         }
  3026.         throw MappingException::noFieldNameFoundForColumn($this->name, $columnName);
  3027.     }
  3029.     /**
  3030.      * Sets the ID generator used to generate IDs for instances of this class.
  3031.      *
  3032.      * @param \Doctrine\ORM\Id\AbstractIdGenerator $generator
  3033.      *
  3034.      * @return void
  3035.      */
  3036.     public function setIdGenerator($generator)
  3037.     {
  3038.         $this->idGenerator = $generator;
  3039.     }
  3041.     /**
  3042.      * Sets definition.
  3043.      *
  3044.      * @param array $definition
  3045.      *
  3046.      * @return void
  3047.      */
  3048.     public function setCustomGeneratorDefinition(array $definition)
  3049.     {
  3050.         $this->customGeneratorDefinition = $definition;
  3051.     }
  3053.     /**
  3054.      * Sets the definition of the sequence ID generator for this class.
  3055.      *
  3056.      * The definition must have the following structure:
  3057.      * <code>
  3058.      * array(
  3059.      *     'sequenceName'   => 'name',
  3060.      *     'allocationSize' => 20,
  3061.      *     'initialValue'   => 1
  3062.      *     'quoted'         => 1
  3063.      * )
  3064.      * </code>
  3065.      *
  3066.      * @param array $definition
  3067.      *
  3068.      * @return void
  3069.      *
  3070.      * @throws MappingException
  3071.      */
  3072.     public function setSequenceGeneratorDefinition(array $definition)
  3073.     {
  3074.         if ( ! isset($definition['sequenceName']) || trim($definition['sequenceName']) === '') {
  3075.             throw MappingException::missingSequenceName($this->name);
  3076.         }
  3078.         if ($definition['sequenceName'][0] == '`') {
  3079.             $definition['sequenceName']   = trim($definition['sequenceName'], '`');
  3080.             $definition['quoted'] = true;
  3081.         }
  3083.         if ( ! isset($definition['allocationSize']) || trim($definition['allocationSize']) === '') {
  3084.             $definition['allocationSize'] = '1';
  3085.         }
  3087.         if ( ! isset($definition['initialValue']) || trim($definition['initialValue']) === '') {
  3088.             $definition['initialValue'] = '1';
  3089.         }
  3091.         $this->sequenceGeneratorDefinition = $definition;
  3092.     }
  3094.     /**
  3095.      * Sets the version field mapping used for versioning. Sets the default
  3096.      * value to use depending on the column type.
  3097.      *
  3098.      * @param array $mapping The version field mapping array.
  3099.      *
  3100.      * @return void
  3101.      *
  3102.      * @throws MappingException
  3103.      */
  3104.     public function setVersionMapping(array &$mapping)
  3105.     {
  3106.         $this->isVersioned = true;
  3107.         $this->versionField = $mapping['fieldName'];
  3109.         if ( ! isset($mapping['default'])) {
  3110.             if (in_array($mapping['type'], ['integer', 'bigint', 'smallint'])) {
  3111.                 $mapping['default'] = 1;
  3112.             } else if ($mapping['type'] == 'datetime') {
  3113.                 $mapping['default'] = 'CURRENT_TIMESTAMP';
  3114.             } else {
  3115.                 throw MappingException::unsupportedOptimisticLockingType($this->name, $mapping['fieldName'], $mapping['type']);
  3116.             }
  3117.         }
  3118.     }
  3120.     /**
  3121.      * Sets whether this class is to be versioned for optimistic locking.
  3122.      *
  3123.      * @param boolean $bool
  3124.      *
  3125.      * @return void
  3126.      */
  3127.     public function setVersioned($bool)
  3128.     {
  3129.         $this->isVersioned = $bool;
  3130.     }
  3132.     /**
  3133.      * Sets the name of the field that is to be used for versioning if this class is
  3134.      * versioned for optimistic locking.
  3135.      *
  3136.      * @param string $versionField
  3137.      *
  3138.      * @return void
  3139.      */
  3140.     public function setVersionField($versionField)
  3141.     {
  3142.         $this->versionField = $versionField;
  3143.     }
  3145.     /**
  3146.      * Marks this class as read only, no change tracking is applied to it.
  3147.      *
  3148.      * @return void
  3149.      */
  3150.     public function markReadOnly()
  3151.     {
  3152.         $this->isReadOnly = true;
  3153.     }
  3155.     /**
  3156.      * {@inheritDoc}
  3157.      */
  3158.     public function getFieldNames()
  3159.     {
  3160.         return array_keys($this->fieldMappings);
  3161.     }
  3163.     /**
  3164.      * {@inheritDoc}
  3165.      */
  3166.     public function getAssociationNames()
  3167.     {
  3168.         return array_keys($this->associationMappings);
  3169.     }
  3171.     /**
  3172.      * {@inheritDoc}
  3173.      *
  3174.      * @throws InvalidArgumentException
  3175.      */
  3176.     public function getAssociationTargetClass($assocName)
  3177.     {
  3178.         if ( ! isset($this->associationMappings[$assocName])) {
  3179.             throw new InvalidArgumentException("Association name expected, '" . $assocName ."' is not an association.");
  3180.         }
  3182.         return $this->associationMappings[$assocName]['targetEntity'];
  3183.     }
  3185.     /**
  3186.      * {@inheritDoc}
  3187.      */
  3188.     public function getName()
  3189.     {
  3190.         return $this->name;
  3191.     }
  3193.     /**
  3194.      * Gets the (possibly quoted) identifier column names for safe use in an SQL statement.
  3195.      *
  3196.      * @deprecated Deprecated since version 2.3 in favor of \Doctrine\ORM\Mapping\QuoteStrategy
  3197.      *
  3198.      * @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
  3199.      *
  3200.      * @return array
  3201.      */
  3202.     public function getQuotedIdentifierColumnNames($platform)
  3203.     {
  3204.         $quotedColumnNames = [];
  3206.         foreach ($this->identifier as $idProperty) {
  3207.             if (isset($this->fieldMappings[$idProperty])) {
  3208.                 $quotedColumnNames[] = isset($this->fieldMappings[$idProperty]['quoted'])
  3209.                     ? $platform->quoteIdentifier($this->fieldMappings[$idProperty]['columnName'])
  3210.                     : $this->fieldMappings[$idProperty]['columnName'];
  3212.                 continue;
  3213.             }
  3215.             // Association defined as Id field
  3216.             $joinColumns            = $this->associationMappings[$idProperty]['joinColumns'];
  3217.             $assocQuotedColumnNames = array_map(
  3218.                 function ($joinColumn) use ($platform) {
  3219.                     return isset($joinColumn['quoted'])
  3220.                         ? $platform->quoteIdentifier($joinColumn['name'])
  3221.                         : $joinColumn['name'];
  3222.                 },
  3223.                 $joinColumns
  3224.             );
  3226.             $quotedColumnNames = array_merge($quotedColumnNames, $assocQuotedColumnNames);
  3227.         }
  3229.         return $quotedColumnNames;
  3230.     }
  3232.     /**
  3233.      * Gets the (possibly quoted) column name of a mapped field for safe use  in an SQL statement.
  3234.      *
  3235.      * @deprecated Deprecated since version 2.3 in favor of \Doctrine\ORM\Mapping\QuoteStrategy
  3236.      *
  3237.      * @param string                                    $field
  3238.      * @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
  3239.      *
  3240.      * @return string
  3241.      */
  3242.     public function getQuotedColumnName($field, $platform)
  3243.     {
  3244.         return isset($this->fieldMappings[$field]['quoted'])
  3245.             ? $platform->quoteIdentifier($this->fieldMappings[$field]['columnName'])
  3246.             : $this->fieldMappings[$field]['columnName'];
  3247.     }
  3249.     /**
  3250.      * Gets the (possibly quoted) primary table name of this class for safe use in an SQL statement.
  3251.      *
  3252.      * @deprecated Deprecated since version 2.3 in favor of \Doctrine\ORM\Mapping\QuoteStrategy
  3253.      *
  3254.      * @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
  3255.      *
  3256.      * @return string
  3257.      */
  3258.     public function getQuotedTableName($platform)
  3259.     {
  3260.         return isset($this->table['quoted'])
  3261.             ? $platform->quoteIdentifier($this->table['name'])
  3262.             : $this->table['name'];
  3263.     }
  3265.     /**
  3266.      * Gets the (possibly quoted) name of the join table.
  3267.      *
  3268.      * @deprecated Deprecated since version 2.3 in favor of \Doctrine\ORM\Mapping\QuoteStrategy
  3269.      *
  3270.      * @param array                                     $assoc
  3271.      * @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
  3272.      *
  3273.      * @return string
  3274.      */
  3275.     public function getQuotedJoinTableName(array $assoc, $platform)
  3276.     {
  3277.         return isset($assoc['joinTable']['quoted'])
  3278.             ? $platform->quoteIdentifier($assoc['joinTable']['name'])
  3279.             : $assoc['joinTable']['name'];
  3280.     }
  3282.     /**
  3283.      * {@inheritDoc}
  3284.      */
  3285.     public function isAssociationInverseSide($fieldName)
  3286.     {
  3287.         return isset($this->associationMappings[$fieldName])
  3288.             && ! $this->associationMappings[$fieldName]['isOwningSide'];
  3289.     }
  3291.     /**
  3292.      * {@inheritDoc}
  3293.      */
  3294.     public function getAssociationMappedByTargetField($fieldName)
  3295.     {
  3296.         return $this->associationMappings[$fieldName]['mappedBy'];
  3297.     }
  3299.     /**
  3300.      * @param string $targetClass
  3301.      *
  3302.      * @return array
  3303.      */
  3304.     public function getAssociationsByTargetClass($targetClass)
  3305.     {
  3306.         $relations = [];
  3308.         foreach ($this->associationMappings as $mapping) {
  3309.             if ($mapping['targetEntity'] == $targetClass) {
  3310.                 $relations[$mapping['fieldName']] = $mapping;
  3311.             }
  3312.         }
  3314.         return $relations;
  3315.     }
  3317.     /**
  3318.      * @param  string|null $className
  3319.      *
  3320.      * @return string|null null if the input value is null
  3321.      *
  3322.      * @psalm-param ?class-string $className
  3323.      */
  3324.     public function fullyQualifiedClassName($className)
  3325.     {
  3326.         if (empty($className)) {
  3327.             return $className;
  3328.         }
  3330.         if ($className !== null && strpos($className, '\\') === false && $this->namespace) {
  3331.             return $this->namespace . '\\' . $className;
  3332.         }
  3334.         return $className;
  3335.     }
  3337.     /**
  3338.      * @param string $name
  3339.      *
  3340.      * @return mixed
  3341.      */
  3342.     public function getMetadataValue($name)
  3343.     {
  3345.         if (isset($this->$name)) {
  3346.             return $this->$name;
  3347.         }
  3349.         return null;
  3350.     }
  3352.     /**
  3353.      * Map Embedded Class
  3354.      *
  3355.      * @param array $mapping
  3356.      *
  3357.      * @throws MappingException
  3358.      * @return void
  3359.      */
  3360.     public function mapEmbedded(array $mapping)
  3361.     {
  3362.         $this->assertFieldNotMapped($mapping['fieldName']);
  3364.         $this->embeddedClasses[$mapping['fieldName']] = [
  3365.             'class' => $this->fullyQualifiedClassName($mapping['class']),
  3366.             'columnPrefix' => $mapping['columnPrefix'],
  3367.             'declaredField' => $mapping['declaredField'] ?? null,
  3368.             'originalField' => $mapping['originalField'] ?? null,
  3369.         ];
  3370.     }
  3372.     /**
  3373.      * Inline the embeddable class
  3374.      *
  3375.      * @param string            $property
  3376.      * @param ClassMetadataInfo $embeddable
  3377.      */
  3378.     public function inlineEmbeddable($property, ClassMetadataInfo $embeddable)
  3379.     {
  3380.         foreach ($embeddable->fieldMappings as $fieldMapping) {
  3381.             $fieldMapping['originalClass'] = $fieldMapping['originalClass'] ?? $embeddable->name;
  3382.             $fieldMapping['declaredField'] = isset($fieldMapping['declaredField'])
  3383.                 ? $property . '.' . $fieldMapping['declaredField']
  3384.                 : $property;
  3385.             $fieldMapping['originalField'] = $fieldMapping['originalField'] ?? $fieldMapping['fieldName'];
  3386.             $fieldMapping['fieldName'] = $property . "." . $fieldMapping['fieldName'];
  3388.             if (! empty($this->embeddedClasses[$property]['columnPrefix'])) {
  3389.                 $fieldMapping['columnName'] = $this->embeddedClasses[$property]['columnPrefix'] . $fieldMapping['columnName'];
  3390.             } elseif ($this->embeddedClasses[$property]['columnPrefix'] !== false) {
  3391.                 $fieldMapping['columnName'] = $this->namingStrategy
  3392.                     ->embeddedFieldToColumnName(
  3393.                         $property,
  3394.                         $fieldMapping['columnName'],
  3395.                         $this->reflClass->name,
  3396.                         $embeddable->reflClass->name
  3397.                     );
  3398.             }
  3400.             $this->mapField($fieldMapping);
  3401.         }
  3402.     }
  3404.     /**
  3405.      * @param string $fieldName
  3406.      * @throws MappingException
  3407.      */
  3408.     private function assertFieldNotMapped($fieldName)
  3409.     {
  3410.         if (isset($this->fieldMappings[$fieldName]) ||
  3411.             isset($this->associationMappings[$fieldName]) ||
  3412.             isset($this->embeddedClasses[$fieldName])) {
  3414.             throw MappingException::duplicateFieldMapping($this->name, $fieldName);
  3415.         }
  3416.     }
  3418.     /**
  3419.      * Gets the sequence name based on class metadata.
  3420.      *
  3421.      * @param AbstractPlatform $platform
  3422.      * @return string
  3423.      *
  3424.      * @todo Sequence names should be computed in DBAL depending on the platform
  3425.      */
  3426.     public function getSequenceName(AbstractPlatform $platform)
  3427.     {
  3428.         $sequencePrefix = $this->getSequencePrefix($platform);
  3429.         $columnName     = $this->getSingleIdentifierColumnName();
  3430.         $sequenceName   = $sequencePrefix . '_' . $columnName . '_seq';
  3432.         return $sequenceName;
  3433.     }
  3435.     /**
  3436.      * Gets the sequence name prefix based on class metadata.
  3437.      *
  3438.      * @param AbstractPlatform $platform
  3439.      * @return string
  3440.      *
  3441.      * @todo Sequence names should be computed in DBAL depending on the platform
  3442.      */
  3443.     public function getSequencePrefix(AbstractPlatform $platform)
  3444.     {
  3445.         $tableName      = $this->getTableName();
  3446.         $sequencePrefix = $tableName;
  3448.         // Prepend the schema name to the table name if there is one
  3449.         if ($schemaName = $this->getSchemaName()) {
  3450.             $sequencePrefix = $schemaName . '.' . $tableName;
  3452.             if ( ! $platform->supportsSchemas() && $platform->canEmulateSchemas()) {
  3453.                 $sequencePrefix = $schemaName . '__' . $tableName;
  3454.             }
  3455.         }
  3457.         return $sequencePrefix;
  3458.     }
  3460.     /**
  3461.      * @param array $mapping
  3462.      */
  3463.     private function assertMappingOrderBy(array $mapping)
  3464.     {
  3465.         if (isset($mapping['orderBy']) && !is_array($mapping['orderBy'])) {
  3466.             throw new InvalidArgumentException("'orderBy' is expected to be an array, not " . gettype($mapping['orderBy']));
  3467.         }
  3468.     }
  3469. }