1. <?php
3. declare(strict_types=1);
5. namespace Doctrine\ORM\Mapping;
7. use BackedEnum;
8. use BadMethodCallException;
9. use Doctrine\DBAL\Platforms\AbstractPlatform;
10. use Doctrine\DBAL\Types\Type;
11. use Doctrine\Deprecations\Deprecation;
12. use Doctrine\Instantiator\Instantiator;
13. use Doctrine\Instantiator\InstantiatorInterface;
14. use Doctrine\ORM\Cache\Exception\NonCacheableEntityAssociation;
15. use Doctrine\ORM\EntityRepository;
16. use Doctrine\ORM\Id\AbstractIdGenerator;
17. use Doctrine\Persistence\Mapping\ClassMetadata;
18. use Doctrine\Persistence\Mapping\ReflectionService;
19. use InvalidArgumentException;
20. use LogicException;
21. use ReflectionClass;
22. use ReflectionNamedType;
23. use ReflectionProperty;
24. use RuntimeException;
26. use function array_diff;
27. use function array_flip;
28. use function array_intersect;
29. use function array_keys;
30. use function array_map;
31. use function array_merge;
32. use function array_pop;
33. use function array_values;
34. use function assert;
35. use function class_exists;
36. use function count;
37. use function enum_exists;
38. use function explode;
39. use function gettype;
40. use function in_array;
41. use function interface_exists;
42. use function is_array;
43. use function is_subclass_of;
44. use function ltrim;
45. use function method_exists;
46. use function spl_object_id;
47. use function str_contains;
48. use function str_replace;
49. use function strtolower;
50. use function trait_exists;
51. use function trim;
53. use const PHP_VERSION_ID;
55. /**
56.  * A <tt>ClassMetadata</tt> instance holds all the object-relational mapping metadata
57.  * of an entity and its associations.
58.  *
59.  * Once populated, ClassMetadata instances are usually cached in a serialized form.
60.  *
61.  * <b>IMPORTANT NOTE:</b>
62.  *
63.  * The fields of this class are only public for 2 reasons:
64.  * 1) To allow fast READ access.
65.  * 2) To drastically reduce the size of a serialized instance (private/protected members
66.  *    get the whole class name, namespace inclusive, prepended to every property in
67.  *    the serialized representation).
68.  *
69.  * @template-covariant T of object
70.  * @template-implements ClassMetadata<T>
71.  * @psalm-import-type AssociationMapping from \Doctrine\ORM\Mapping\ClassMetadata
72.  * @psalm-import-type FieldMapping from \Doctrine\ORM\Mapping\ClassMetadata
73.  * @psalm-import-type EmbeddedClassMapping from \Doctrine\ORM\Mapping\ClassMetadata
74.  * @psalm-import-type JoinColumnData from \Doctrine\ORM\Mapping\ClassMetadata
75.  * @psalm-import-type DiscriminatorColumnMapping from \Doctrine\ORM\Mapping\ClassMetadata
76.  */
77. class ClassMetadataInfo implements ClassMetadata
78. {
79.     /* The inheritance mapping types */
80.     /**
81.      * NONE means the class does not participate in an inheritance hierarchy
82.      * and therefore does not need an inheritance mapping type.
83.      */
84.     public const INHERITANCE_TYPE_NONE = 1;
86.     /**
87.      * JOINED means the class will be persisted according to the rules of
88.      * <tt>Class Table Inheritance</tt>.
89.      */
90.     public const INHERITANCE_TYPE_JOINED = 2;
92.     /**
93.      * SINGLE_TABLE means the class will be persisted according to the rules of
94.      * <tt>Single Table Inheritance</tt>.
95.      */
96.     public const INHERITANCE_TYPE_SINGLE_TABLE = 3;
98.     /**
99.      * TABLE_PER_CLASS means the class will be persisted according to the rules
100.      * of <tt>Concrete Table Inheritance</tt>.
101.      *
102.      * @deprecated
103.      */
104.     public const INHERITANCE_TYPE_TABLE_PER_CLASS = 4;
106.     /* The Id generator types. */
107.     /**
108.      * AUTO means the generator type will depend on what the used platform prefers.
109.      * Offers full portability.
110.      */
111.     public const GENERATOR_TYPE_AUTO = 1;
113.     /**
114.      * SEQUENCE means a separate sequence object will be used. Platforms that do
115.      * not have native sequence support may emulate it. Full portability is currently
116.      * not guaranteed.
117.      */
118.     public const GENERATOR_TYPE_SEQUENCE = 2;
120.     /**
121.      * TABLE means a separate table is used for id generation.
122.      * Offers full portability (in that it results in an exception being thrown
123.      * no matter the platform).
124.      *
125.      * @deprecated no replacement planned
126.      */
127.     public const GENERATOR_TYPE_TABLE = 3;
129.     /**
130.      * IDENTITY means an identity column is used for id generation. The database
131.      * will fill in the id column on insertion. Platforms that do not support
132.      * native identity columns may emulate them. Full portability is currently
133.      * not guaranteed.
134.      */
135.     public const GENERATOR_TYPE_IDENTITY = 4;
137.     /**
138.      * NONE means the class does not have a generated id. That means the class
139.      * must have a natural, manually assigned id.
140.      */
141.     public const GENERATOR_TYPE_NONE = 5;
143.     /**
144.      * UUID means that a UUID/GUID expression is used for id generation. Full
145.      * portability is currently not guaranteed.
146.      *
147.      * @deprecated use an application-side generator instead
148.      */
149.     public const GENERATOR_TYPE_UUID = 6;
151.     /**
152.      * CUSTOM means that customer will use own ID generator that supposedly work
153.      */
154.     public const GENERATOR_TYPE_CUSTOM = 7;
156.     /**
157.      * DEFERRED_IMPLICIT means that changes of entities are calculated at commit-time
158.      * by doing a property-by-property comparison with the original data. This will
159.      * be done for all entities that are in MANAGED state at commit-time.
160.      *
161.      * This is the default change tracking policy.
162.      */
163.     public const CHANGETRACKING_DEFERRED_IMPLICIT = 1;
165.     /**
166.      * DEFERRED_EXPLICIT means that changes of entities are calculated at commit-time
167.      * by doing a property-by-property comparison with the original data. This will
168.      * be done only for entities that were explicitly saved (through persist() or a cascade).
169.      */
170.     public const CHANGETRACKING_DEFERRED_EXPLICIT = 2;
172.     /**
173.      * NOTIFY means that Doctrine relies on the entities sending out notifications
174.      * when their properties change. Such entity classes must implement
175.      * the <tt>NotifyPropertyChanged</tt> interface.
176.      */
177.     public const CHANGETRACKING_NOTIFY = 3;
179.     /**
180.      * Specifies that an association is to be fetched when it is first accessed.
181.      */
182.     public const FETCH_LAZY = 2;
184.     /**
185.      * Specifies that an association is to be fetched when the owner of the
186.      * association is fetched.
187.      */
188.     public const FETCH_EAGER = 3;
190.     /**
191.      * Specifies that an association is to be fetched lazy (on first access) and that
192.      * commands such as Collection#count, Collection#slice are issued directly against
193.      * the database if the collection is not yet initialized.
194.      */
195.     public const FETCH_EXTRA_LAZY = 4;
197.     /**
198.      * Identifies a one-to-one association.
199.      */
200.     public const ONE_TO_ONE = 1;
202.     /**
203.      * Identifies a many-to-one association.
204.      */
205.     public const MANY_TO_ONE = 2;
207.     /**
208.      * Identifies a one-to-many association.
209.      */
210.     public const ONE_TO_MANY = 4;
212.     /**
213.      * Identifies a many-to-many association.
214.      */
215.     public const MANY_TO_MANY = 8;
217.     /**
218.      * Combined bitmask for to-one (single-valued) associations.
219.      */
220.     public const TO_ONE = 3;
222.     /**
223.      * Combined bitmask for to-many (collection-valued) associations.
224.      */
225.     public const TO_MANY = 12;
227.     /**
228.      * ReadOnly cache can do reads, inserts and deletes, cannot perform updates or employ any locks,
229.      */
230.     public const CACHE_USAGE_READ_ONLY = 1;
232.     /**
233.      * Nonstrict Read Write Cache doesn’t employ any locks but can do inserts, update and deletes.
234.      */
235.     public const CACHE_USAGE_NONSTRICT_READ_WRITE = 2;
237.     /**
238.      * Read Write Attempts to lock the entity before update/delete.
239.      */
240.     public const CACHE_USAGE_READ_WRITE = 3;
242.     /**
243.      * The value of this column is never generated by the database.
244.      */
245.     public const GENERATED_NEVER = 0;
247.     /**
248.      * The value of this column is generated by the database on INSERT, but not on UPDATE.
249.      */
250.     public const GENERATED_INSERT = 1;
252.     /**
253.      * The value of this column is generated by the database on both INSERT and UDPATE statements.
254.      */
255.     public const GENERATED_ALWAYS = 2;
257.     /**
258.      * READ-ONLY: The name of the entity class.
259.      *
260.      * @var string
261.      * @psalm-var class-string<T>
262.      */
263.     public $name;
265.     /**
266.      * READ-ONLY: The namespace the entity class is contained in.
267.      *
268.      * @var string
269.      * @todo Not really needed. Usage could be localized.
270.      */
271.     public $namespace;
273.     /**
274.      * READ-ONLY: The name of the entity class that is at the root of the mapped entity inheritance
275.      * hierarchy. If the entity is not part of a mapped inheritance hierarchy this is the same
276.      * as {@link $name}.
277.      *
278.      * @var string
279.      * @psalm-var class-string
280.      */
281.     public $rootEntityName;
283.     /**
284.      * READ-ONLY: The definition of custom generator. Only used for CUSTOM
285.      * generator type
286.      *
287.      * The definition has the following structure:
288.      * <code>
289.      * array(
290.      *     'class' => 'ClassName',
291.      * )
292.      * </code>
293.      *
294.      * @todo Merge with tableGeneratorDefinition into generic generatorDefinition
295.      * @var array<string, string>|null
296.      */
297.     public $customGeneratorDefinition;
299.     /**
300.      * The name of the custom repository class used for the entity class.
301.      * (Optional).
302.      *
303.      * @var string|null
304.      * @psalm-var ?class-string<EntityRepository>
305.      */
306.     public $customRepositoryClassName;
308.     /**
309.      * READ-ONLY: Whether this class describes the mapping of a mapped superclass.
310.      *
311.      * @var bool
312.      */
313.     public $isMappedSuperclass = false;
315.     /**
316.      * READ-ONLY: Whether this class describes the mapping of an embeddable class.
317.      *
318.      * @var bool
319.      */
320.     public $isEmbeddedClass = false;
322.     /**
323.      * READ-ONLY: The names of the parent <em>entity</em> classes (ancestors), starting with the
324.      * nearest one and ending with the root entity class.
325.      *
326.      * @psalm-var list<class-string>
327.      */
328.     public $parentClasses = [];
330.     /**
331.      * READ-ONLY: For classes in inheritance mapping hierarchies, this field contains the names of all
332.      * <em>entity</em> subclasses of this class. These may also be abstract classes.
333.      *
334.      * This list is used, for example, to enumerate all necessary tables in JTI when querying for root
335.      * or subclass entities, or to gather all fields comprised in an entity inheritance tree.
336.      *
337.      * For classes that do not use STI/JTI, this list is empty.
338.      *
339.      * Implementation note:
340.      *
341.      * In PHP, there is no general way to discover all subclasses of a given class at runtime. For that
342.      * reason, the list of classes given in the discriminator map at the root entity is considered
343.      * authoritative. The discriminator map must contain all <em>concrete</em> classes that can
344.      * appear in the particular inheritance hierarchy tree. Since there can be no instances of abstract
345.      * entity classes, users are not required to list such classes with a discriminator value.
346.      *
347.      * The possibly remaining "gaps" for abstract entity classes are filled after the class metadata for the
348.      * root entity has been loaded.
349.      *
350.      * For subclasses of such root entities, the list can be reused/passed downwards, it only needs to
351.      * be filtered accordingly (only keep remaining subclasses)
352.      *
353.      * @psalm-var list<class-string>
354.      */
355.     public $subClasses = [];
357.     /**
358.      * READ-ONLY: The names of all embedded classes based on properties.
359.      *
360.      * The value (definition) array may contain, among others, the following values:
361.      *
362.      * - <b>'inherited'</b> (string, optional)
363.      * This is set when this embedded-class field is inherited by this class from another (inheritance) parent
364.      * <em>entity</em> class. The value is the FQCN of the topmost entity class that contains
365.      * mapping information for this field. (If there are transient classes in the
366.      * class hierarchy, these are ignored, so the class property may in fact come
367.      * from a class further up in the PHP class hierarchy.)
368.      * Fields initially declared in mapped superclasses are
369.      * <em>not</em> considered 'inherited' in the nearest entity subclasses.
370.      *
371.      * - <b>'declared'</b> (string, optional)
372.      * This is set when the embedded-class field does not appear for the first time in this class, but is originally
373.      * declared in another parent <em>entity or mapped superclass</em>. The value is the FQCN
374.      * of the topmost non-transient class that contains mapping information for this field.
375.      *
376.      * @psalm-var array<string, EmbeddedClassMapping>
377.      */
378.     public $embeddedClasses = [];
380.     /**
381.      * READ-ONLY: The named queries allowed to be called directly from Repository.
382.      *
383.      * @psalm-var array<string, array<string, mixed>>
384.      */
385.     public $namedQueries = [];
387.     /**
388.      * READ-ONLY: The named native queries allowed to be called directly from Repository.
389.      *
390.      * A native SQL named query definition has the following structure:
391.      * <pre>
392.      * array(
393.      *     'name'               => <query name>,
394.      *     'query'              => <sql query>,
395.      *     'resultClass'        => <class of the result>,
396.      *     'resultSetMapping'   => <name of a SqlResultSetMapping>
397.      * )
398.      * </pre>
399.      *
400.      * @psalm-var array<string, array<string, mixed>>
401.      */
402.     public $namedNativeQueries = [];
404.     /**
405.      * READ-ONLY: The mappings of the results of native SQL queries.
406.      *
407.      * A native result mapping definition has the following structure:
408.      * <pre>
409.      * array(
410.      *     'name'               => <result name>,
411.      *     'entities'           => array(<entity result mapping>),
412.      *     'columns'            => array(<column result mapping>)
413.      * )
414.      * </pre>
415.      *
416.      * @psalm-var array<string, array{
417.      *                name: string,
418.      *                entities: mixed[],
419.      *                columns: mixed[]
420.      *            }>
421.      */
422.     public $sqlResultSetMappings = [];
424.     /**
425.      * READ-ONLY: The field names of all fields that are part of the identifier/primary key
426.      * of the mapped entity class.
427.      *
428.      * @psalm-var list<string>
429.      */
430.     public $identifier = [];
432.     /**
433.      * READ-ONLY: The inheritance mapping type used by the class.
434.      *
435.      * @var int
436.      * @psalm-var self::INHERITANCE_TYPE_*
437.      */
438.     public $inheritanceType = self::INHERITANCE_TYPE_NONE;
440.     /**
441.      * READ-ONLY: The Id generator type used by the class.
442.      *
443.      * @var int
444.      * @psalm-var self::GENERATOR_TYPE_*
445.      */
446.     public $generatorType = self::GENERATOR_TYPE_NONE;
448.     /**
449.      * READ-ONLY: The field mappings of the class.
450.      * Keys are field names and values are mapping definitions.
451.      *
452.      * The mapping definition array has the following values:
453.      *
454.      * - <b>fieldName</b> (string)
455.      * The name of the field in the Entity.
456.      *
457.      * - <b>type</b> (string)
458.      * The type name of the mapped field. Can be one of Doctrine's mapping types
459.      * or a custom mapping type.
460.      *
461.      * - <b>columnName</b> (string, optional)
462.      * The column name. Optional. Defaults to the field name.
463.      *
464.      * - <b>length</b> (integer, optional)
465.      * The database length of the column. Optional. Default value taken from
466.      * the type.
467.      *
468.      * - <b>id</b> (boolean, optional)
469.      * Marks the field as the primary key of the entity. Multiple fields of an
470.      * entity can have the id attribute, forming a composite key.
471.      *
472.      * - <b>nullable</b> (boolean, optional)
473.      * Whether the column is nullable. Defaults to FALSE.
474.      *
475.      * - <b>'notInsertable'</b> (boolean, optional)
476.      * Whether the column is not insertable. Optional. Is only set if value is TRUE.
477.      *
478.      * - <b>'notUpdatable'</b> (boolean, optional)
479.      * Whether the column is updatable. Optional. Is only set if value is TRUE.
480.      *
481.      * - <b>columnDefinition</b> (string, optional, schema-only)
482.      * The SQL fragment that is used when generating the DDL for the column.
483.      *
484.      * - <b>precision</b> (integer, optional, schema-only)
485.      * The precision of a decimal column. Only valid if the column type is decimal.
486.      *
487.      * - <b>scale</b> (integer, optional, schema-only)
488.      * The scale of a decimal column. Only valid if the column type is decimal.
489.      *
490.      * - <b>'unique'</b> (boolean, optional, schema-only)
491.      * Whether a unique constraint should be generated for the column.
492.      *
493.      * - <b>'inherited'</b> (string, optional)
494.      * This is set when the field is inherited by this class from another (inheritance) parent
495.      * <em>entity</em> class. The value is the FQCN of the topmost entity class that contains
496.      * mapping information for this field. (If there are transient classes in the
497.      * class hierarchy, these are ignored, so the class property may in fact come
498.      * from a class further up in the PHP class hierarchy.)
499.      * Fields initially declared in mapped superclasses are
500.      * <em>not</em> considered 'inherited' in the nearest entity subclasses.
501.      *
502.      * - <b>'declared'</b> (string, optional)
503.      * This is set when the field does not appear for the first time in this class, but is originally
504.      * declared in another parent <em>entity or mapped superclass</em>. The value is the FQCN
505.      * of the topmost non-transient class that contains mapping information for this field.
506.      *
507.      * @var mixed[]
508.      * @psalm-var array<string, FieldMapping>
509.      */
510.     public $fieldMappings = [];
512.     /**
513.      * READ-ONLY: An array of field names. Used to look up field names from column names.
514.      * Keys are column names and values are field names.
515.      *
516.      * @psalm-var array<string, string>
517.      */
518.     public $fieldNames = [];
520.     /**
521.      * READ-ONLY: A map of field names to column names. Keys are field names and values column names.
522.      * Used to look up column names from field names.
523.      * This is the reverse lookup map of $_fieldNames.
524.      *
525.      * @deprecated 3.0 Remove this.
526.      *
527.      * @var mixed[]
528.      */
529.     public $columnNames = [];
531.     /**
532.      * READ-ONLY: The discriminator value of this class.
533.      *
534.      * <b>This does only apply to the JOINED and SINGLE_TABLE inheritance mapping strategies
535.      * where a discriminator column is used.</b>
536.      *
537.      * @see discriminatorColumn
538.      *
539.      * @var mixed
540.      */
541.     public $discriminatorValue;
543.     /**
544.      * READ-ONLY: The discriminator map of all mapped classes in the hierarchy.
545.      *
546.      * <b>This does only apply to the JOINED and SINGLE_TABLE inheritance mapping strategies
547.      * where a discriminator column is used.</b>
548.      *
549.      * @see discriminatorColumn
550.      *
551.      * @var array<int|string, string>
552.      *
553.      * @psalm-var array<int|string, class-string>
554.      */
555.     public $discriminatorMap = [];
557.     /**
558.      * READ-ONLY: The definition of the discriminator column used in JOINED and SINGLE_TABLE
559.      * inheritance mappings.
560.      *
561.      * @var array<string, mixed>
562.      * @psalm-var DiscriminatorColumnMapping|null
563.      */
564.     public $discriminatorColumn;
566.     /**
567.      * READ-ONLY: The primary table definition. The definition is an array with the
568.      * following entries:
569.      *
570.      * name => <tableName>
571.      * schema => <schemaName>
572.      * indexes => array
573.      * uniqueConstraints => array
574.      *
575.      * @var mixed[]
576.      * @psalm-var array{
577.      *               name: string,
578.      *               schema?: string,
579.      *               indexes?: array,
580.      *               uniqueConstraints?: array,
581.      *               options?: array<string, mixed>,
582.      *               quoted?: bool
583.      *           }
584.      */
585.     public $table;
587.     /**
588.      * READ-ONLY: The registered lifecycle callbacks for entities of this class.
589.      *
590.      * @psalm-var array<string, list<string>>
591.      */
592.     public $lifecycleCallbacks = [];
594.     /**
595.      * READ-ONLY: The registered entity listeners.
596.      *
597.      * @psalm-var array<string, list<array{class: class-string, method: string}>>
598.      */
599.     public $entityListeners = [];
601.     /**
602.      * READ-ONLY: The association mappings of this class.
603.      *
604.      * The mapping definition array supports the following keys:
605.      *
606.      * - <b>fieldName</b> (string)
607.      * The name of the field in the entity the association is mapped to.
608.      *
609.      * - <b>sourceEntity</b> (string)
610.      * The class name of the source entity. In the case of to-many associations initially
611.      * present in mapped superclasses, the nearest <em>entity</em> subclasses will be
612.      * considered the respective source entities.
613.      *
614.      * - <b>targetEntity</b> (string)
615.      * The class name of the target entity. If it is fully-qualified it is used as is.
616.      * If it is a simple, unqualified class name the namespace is assumed to be the same
617.      * as the namespace of the source entity.
618.      *
619.      * - <b>mappedBy</b> (string, required for bidirectional associations)
620.      * The name of the field that completes the bidirectional association on the owning side.
621.      * This key must be specified on the inverse side of a bidirectional association.
622.      *
623.      * - <b>inversedBy</b> (string, required for bidirectional associations)
624.      * The name of the field that completes the bidirectional association on the inverse side.
625.      * This key must be specified on the owning side of a bidirectional association.
626.      *
627.      * - <b>cascade</b> (array, optional)
628.      * The names of persistence operations to cascade on the association. The set of possible
629.      * values are: "persist", "remove", "detach", "merge", "refresh", "all" (implies all others).
630.      *
631.      * - <b>orderBy</b> (array, one-to-many/many-to-many only)
632.      * A map of field names (of the target entity) to sorting directions (ASC/DESC).
633.      * Example: array('priority' => 'desc')
634.      *
635.      * - <b>fetch</b> (integer, optional)
636.      * The fetching strategy to use for the association, usually defaults to FETCH_LAZY.
637.      * Possible values are: ClassMetadata::FETCH_EAGER, ClassMetadata::FETCH_LAZY.
638.      *
639.      * - <b>joinTable</b> (array, optional, many-to-many only)
640.      * Specification of the join table and its join columns (foreign keys).
641.      * Only valid for many-to-many mappings. Note that one-to-many associations can be mapped
642.      * through a join table by simply mapping the association as many-to-many with a unique
643.      * constraint on the join table.
644.      *
645.      * - <b>indexBy</b> (string, optional, to-many only)
646.      * Specification of a field on target-entity that is used to index the collection by.
647.      * This field HAS to be either the primary key or a unique column. Otherwise the collection
648.      * does not contain all the entities that are actually related.
649.      *
650.      * - <b>'inherited'</b> (string, optional)
651.      * This is set when the association is inherited by this class from another (inheritance) parent
652.      * <em>entity</em> class. The value is the FQCN of the topmost entity class that contains
653.      * this association. (If there are transient classes in the
654.      * class hierarchy, these are ignored, so the class property may in fact come
655.      * from a class further up in the PHP class hierarchy.)
656.      * To-many associations initially declared in mapped superclasses are
657.      * <em>not</em> considered 'inherited' in the nearest entity subclasses.
658.      *
659.      * - <b>'declared'</b> (string, optional)
660.      * This is set when the association does not appear in the current class for the first time, but
661.      * is initially declared in another parent <em>entity or mapped superclass</em>. The value is the FQCN
662.      * of the topmost non-transient class that contains association information for this relationship.
663.      *
664.      * A join table definition has the following structure:
665.      * <pre>
666.      * array(
667.      *     'name' => <join table name>,
668.      *      'joinColumns' => array(<join column mapping from join table to source table>),
669.      *      'inverseJoinColumns' => array(<join column mapping from join table to target table>)
670.      * )
671.      * </pre>
672.      *
673.      * @psalm-var array<string, AssociationMapping>
674.      */
675.     public $associationMappings = [];
677.     /**
678.      * READ-ONLY: Flag indicating whether the identifier/primary key of the class is composite.
679.      *
680.      * @var bool
681.      */
682.     public $isIdentifierComposite = false;
684.     /**
685.      * READ-ONLY: Flag indicating whether the identifier/primary key contains at least one foreign key association.
686.      *
687.      * This flag is necessary because some code blocks require special treatment of this cases.
688.      *
689.      * @var bool
690.      */
691.     public $containsForeignIdentifier = false;
693.     /**
694.      * READ-ONLY: Flag indicating whether the identifier/primary key contains at least one ENUM type.
695.      *
696.      * This flag is necessary because some code blocks require special treatment of this cases.
697.      *
698.      * @var bool
699.      */
700.     public $containsEnumIdentifier = false;
702.     /**
703.      * READ-ONLY: The ID generator used for generating IDs for this class.
704.      *
705.      * @var AbstractIdGenerator
706.      * @todo Remove!
707.      */
708.     public $idGenerator;
710.     /**
711.      * READ-ONLY: The definition of the sequence generator of this class. Only used for the
712.      * SEQUENCE generation strategy.
713.      *
714.      * The definition has the following structure:
715.      * <code>
716.      * array(
717.      *     'sequenceName' => 'name',
718.      *     'allocationSize' => '20',
719.      *     'initialValue' => '1'
720.      * )
721.      * </code>
722.      *
723.      * @var array<string, mixed>|null
724.      * @psalm-var array{sequenceName: string, allocationSize: string, initialValue: string, quoted?: mixed}|null
725.      * @todo Merge with tableGeneratorDefinition into generic generatorDefinition
726.      */
727.     public $sequenceGeneratorDefinition;
729.     /**
730.      * READ-ONLY: The definition of the table generator of this class. Only used for the
731.      * TABLE generation strategy.
732.      *
733.      * @deprecated
734.      *
735.      * @var array<string, mixed>
736.      */
737.     public $tableGeneratorDefinition;
739.     /**
740.      * READ-ONLY: The policy used for change-tracking on entities of this class.
741.      *
742.      * @var int
743.      */
744.     public $changeTrackingPolicy = self::CHANGETRACKING_DEFERRED_IMPLICIT;
746.     /**
747.      * READ-ONLY: A Flag indicating whether one or more columns of this class
748.      * have to be reloaded after insert / update operations.
749.      *
750.      * @var bool
751.      */
752.     public $requiresFetchAfterChange = false;
754.     /**
755.      * READ-ONLY: A flag for whether or not instances of this class are to be versioned
756.      * with optimistic locking.
757.      *
758.      * @var bool
759.      */
760.     public $isVersioned = false;
762.     /**
763.      * READ-ONLY: The name of the field which is used for versioning in optimistic locking (if any).
764.      *
765.      * @var string|null
766.      */
767.     public $versionField;
769.     /** @var mixed[]|null */
770.     public $cache;
772.     /**
773.      * The ReflectionClass instance of the mapped class.
774.      *
775.      * @var ReflectionClass|null
776.      */
777.     public $reflClass;
779.     /**
780.      * Is this entity marked as "read-only"?
781.      *
782.      * That means it is never considered for change-tracking in the UnitOfWork. It is a very helpful performance
783.      * optimization for entities that are immutable, either in your domain or through the relation database
784.      * (coming from a view, or a history table for example).
785.      *
786.      * @var bool
787.      */
788.     public $isReadOnly = false;
790.     /**
791.      * NamingStrategy determining the default column and table names.
792.      *
793.      * @var NamingStrategy
794.      */
795.     protected $namingStrategy;
797.     /**
798.      * The ReflectionProperty instances of the mapped class.
799.      *
800.      * @var array<string, ReflectionProperty|null>
801.      */
802.     public $reflFields = [];
804.     /** @var InstantiatorInterface|null */
805.     private $instantiator;
807.     /** @var TypedFieldMapper $typedFieldMapper */
808.     private $typedFieldMapper;
810.     /**
811.      * Initializes a new ClassMetadata instance that will hold the object-relational mapping
812.      * metadata of the class with the given name.
813.      *
814.      * @param string $entityName The name of the entity class the new instance is used for.
815.      * @psalm-param class-string<T> $entityName
816.      */
817.     public function __construct($entityName, ?NamingStrategy $namingStrategy = null, ?TypedFieldMapper $typedFieldMapper = null)
818.     {
819.         $this->name             = $entityName;
820.         $this->rootEntityName   = $entityName;
821.         $this->namingStrategy   = $namingStrategy ?? new DefaultNamingStrategy();
822.         $this->instantiator     = new Instantiator();
823.         $this->typedFieldMapper = $typedFieldMapper ?? new DefaultTypedFieldMapper();
824.     }
826.     /**
827.      * Gets the ReflectionProperties of the mapped class.
828.      *
829.      * @return ReflectionProperty[]|null[] An array of ReflectionProperty instances.
830.      * @psalm-return array<ReflectionProperty|null>
831.      */
832.     public function getReflectionProperties()
833.     {
834.         return $this->reflFields;
835.     }
837.     /**
838.      * Gets a ReflectionProperty for a specific field of the mapped class.
839.      *
840.      * @param string $name
841.      *
842.      * @return ReflectionProperty
843.      */
844.     public function getReflectionProperty($name)
845.     {
846.         return $this->reflFields[$name];
847.     }
849.     /**
850.      * Gets the ReflectionProperty for the single identifier field.
851.      *
852.      * @return ReflectionProperty
853.      *
854.      * @throws BadMethodCallException If the class has a composite identifier.
855.      */
856.     public function getSingleIdReflectionProperty()
857.     {
858.         if ($this->isIdentifierComposite) {
859.             throw new BadMethodCallException('Class ' . $this->name . ' has a composite identifier.');
860.         }
862.         return $this->reflFields[$this->identifier[0]];
863.     }
865.     /**
866.      * Extracts the identifier values of an entity of this class.
867.      *
868.      * For composite identifiers, the identifier values are returned as an array
869.      * with the same order as the field order in {@link identifier}.
870.      *
871.      * @param object $entity
872.      *
873.      * @return array<string, mixed>
874.      */
875.     public function getIdentifierValues($entity)
876.     {
877.         if ($this->isIdentifierComposite) {
878.             $id = [];
880.             foreach ($this->identifier as $idField) {
881.                 $value = $this->reflFields[$idField]->getValue($entity);
883.                 if ($value !== null) {
884.                     $id[$idField] = $value;
885.                 }
886.             }
888.             return $id;
889.         }
891.         $id    = $this->identifier[0];
892.         $value = $this->reflFields[$id]->getValue($entity);
894.         if ($value === null) {
895.             return [];
896.         }
898.         return [$id => $value];
899.     }
901.     /**
902.      * Populates the entity identifier of an entity.
903.      *
904.      * @param object $entity
905.      * @psalm-param array<string, mixed> $id
906.      *
907.      * @return void
908.      *
909.      * @todo Rename to assignIdentifier()
910.      */
911.     public function setIdentifierValues($entity, array $id)
912.     {
913.         foreach ($id as $idField => $idValue) {
914.             $this->reflFields[$idField]->setValue($entity, $idValue);
915.         }
916.     }
918.     /**
919.      * Sets the specified field to the specified value on the given entity.
920.      *
921.      * @param object $entity
922.      * @param string $field
923.      * @param mixed  $value
924.      *
925.      * @return void
926.      */
927.     public function setFieldValue($entity, $field, $value)
928.     {
929.         $this->reflFields[$field]->setValue($entity, $value);
930.     }
932.     /**
933.      * Gets the specified field's value off the given entity.
934.      *
935.      * @param object $entity
936.      * @param string $field
937.      *
938.      * @return mixed
939.      */
940.     public function getFieldValue($entity, $field)
941.     {
942.         return $this->reflFields[$field]->getValue($entity);
943.     }
945.     /**
946.      * Creates a string representation of this instance.
947.      *
948.      * @return string The string representation of this instance.
949.      *
950.      * @todo Construct meaningful string representation.
951.      */
952.     public function __toString()
953.     {
954.         return self::class . '@' . spl_object_id($this);
955.     }
957.     /**
958.      * Determines which fields get serialized.
959.      *
960.      * It is only serialized what is necessary for best unserialization performance.
961.      * That means any metadata properties that are not set or empty or simply have
962.      * their default value are NOT serialized.
963.      *
964.      * Parts that are also NOT serialized because they can not be properly unserialized:
965.      *      - reflClass (ReflectionClass)
966.      *      - reflFields (ReflectionProperty array)
967.      *
968.      * @return string[] The names of all the fields that should be serialized.
969.      */
970.     public function __sleep()
971.     {
972.         // This metadata is always serialized/cached.
973.         $serialized = [
974.             'associationMappings',
975.             'columnNames', //TODO: 3.0 Remove this. Can use fieldMappings[$fieldName]['columnName']
976.             'fieldMappings',
977.             'fieldNames',
978.             'embeddedClasses',
979.             'identifier',
980.             'isIdentifierComposite', // TODO: REMOVE
981.             'name',
982.             'namespace', // TODO: REMOVE
983.             'table',
984.             'rootEntityName',
985.             'idGenerator', //TODO: Does not really need to be serialized. Could be moved to runtime.
986.         ];
988.         // The rest of the metadata is only serialized if necessary.
989.         if ($this->changeTrackingPolicy !== self::CHANGETRACKING_DEFERRED_IMPLICIT) {
990.             $serialized[] = 'changeTrackingPolicy';
991.         }
993.         if ($this->customRepositoryClassName) {
994.             $serialized[] = 'customRepositoryClassName';
995.         }
997.         if ($this->inheritanceType !== self::INHERITANCE_TYPE_NONE) {
998.             $serialized[] = 'inheritanceType';
999.             $serialized[] = 'discriminatorColumn';
1000.             $serialized[] = 'discriminatorValue';
1001.             $serialized[] = 'discriminatorMap';
1002.             $serialized[] = 'parentClasses';
1003.             $serialized[] = 'subClasses';
1004.         }
1006.         if ($this->generatorType !== self::GENERATOR_TYPE_NONE) {
1007.             $serialized[] = 'generatorType';
1008.             if ($this->generatorType === self::GENERATOR_TYPE_SEQUENCE) {
1009.                 $serialized[] = 'sequenceGeneratorDefinition';
1010.             }
1011.         }
1013.         if ($this->isMappedSuperclass) {
1014.             $serialized[] = 'isMappedSuperclass';
1015.         }
1017.         if ($this->isEmbeddedClass) {
1018.             $serialized[] = 'isEmbeddedClass';
1019.         }
1021.         if ($this->containsForeignIdentifier) {
1022.             $serialized[] = 'containsForeignIdentifier';
1023.         }
1025.         if ($this->containsEnumIdentifier) {
1026.             $serialized[] = 'containsEnumIdentifier';
1027.         }
1029.         if ($this->isVersioned) {
1030.             $serialized[] = 'isVersioned';
1031.             $serialized[] = 'versionField';
1032.         }
1034.         if ($this->lifecycleCallbacks) {
1035.             $serialized[] = 'lifecycleCallbacks';
1036.         }
1038.         if ($this->entityListeners) {
1039.             $serialized[] = 'entityListeners';
1040.         }
1042.         if ($this->namedQueries) {
1043.             $serialized[] = 'namedQueries';
1044.         }
1046.         if ($this->namedNativeQueries) {
1047.             $serialized[] = 'namedNativeQueries';
1048.         }
1050.         if ($this->sqlResultSetMappings) {
1051.             $serialized[] = 'sqlResultSetMappings';
1052.         }
1054.         if ($this->isReadOnly) {
1055.             $serialized[] = 'isReadOnly';
1056.         }
1058.         if ($this->customGeneratorDefinition) {
1059.             $serialized[] = 'customGeneratorDefinition';
1060.         }
1062.         if ($this->cache) {
1063.             $serialized[] = 'cache';
1064.         }
1066.         if ($this->requiresFetchAfterChange) {
1067.             $serialized[] = 'requiresFetchAfterChange';
1068.         }
1070.         return $serialized;
1071.     }
1073.     /**
1074.      * Creates a new instance of the mapped class, without invoking the constructor.
1075.      *
1076.      * @return object
1077.      */
1078.     public function newInstance()
1079.     {
1080.         return $this->instantiator->instantiate($this->name);
1081.     }
1083.     /**
1084.      * Restores some state that can not be serialized/unserialized.
1085.      *
1086.      * @param ReflectionService $reflService
1087.      *
1088.      * @return void
1089.      */
1090.     public function wakeupReflection($reflService)
1091.     {
1092.         // Restore ReflectionClass and properties
1093.         $this->reflClass    = $reflService->getClass($this->name);
1094.         $this->instantiator = $this->instantiator ?: new Instantiator();
1096.         $parentReflFields = [];
1098.         foreach ($this->embeddedClasses as $property => $embeddedClass) {
1099.             if (isset($embeddedClass['declaredField'])) {
1100.                 assert($embeddedClass['originalField'] !== null);
1101.                 $childProperty = $this->getAccessibleProperty(
1102.                     $reflService,
1103.                     $this->embeddedClasses[$embeddedClass['declaredField']]['class'],
1104.                     $embeddedClass['originalField']
1105.                 );
1106.                 assert($childProperty !== null);
1107.                 $parentReflFields[$property] = new ReflectionEmbeddedProperty(
1108.                     $parentReflFields[$embeddedClass['declaredField']],
1109.                     $childProperty,
1110.                     $this->embeddedClasses[$embeddedClass['declaredField']]['class']
1111.                 );
1113.                 continue;
1114.             }
1116.             $fieldRefl = $this->getAccessibleProperty(
1117.                 $reflService,
1118.                 $embeddedClass['declared'] ?? $this->name,
1119.                 $property
1120.             );
1122.             $parentReflFields[$property] = $fieldRefl;
1123.             $this->reflFields[$property] = $fieldRefl;
1124.         }
1126.         foreach ($this->fieldMappings as $field => $mapping) {
1127.             if (isset($mapping['declaredField']) && isset($parentReflFields[$mapping['declaredField']])) {
1128.                 $childProperty = $this->getAccessibleProperty($reflService, $mapping['originalClass'], $mapping['originalField']);
1129.                 assert($childProperty !== null);
1131.                 if (isset($mapping['enumType'])) {
1132.                     $childProperty = new ReflectionEnumProperty(
1133.                         $childProperty,
1134.                         $mapping['enumType']
1135.                     );
1136.                 }
1138.                 $this->reflFields[$field] = new ReflectionEmbeddedProperty(
1139.                     $parentReflFields[$mapping['declaredField']],
1140.                     $childProperty,
1141.                     $mapping['originalClass']
1142.                 );
1143.                 continue;
1144.             }
1146.             $this->reflFields[$field] = isset($mapping['declared'])
1147.                 ? $this->getAccessibleProperty($reflService, $mapping['declared'], $field)
1148.                 : $this->getAccessibleProperty($reflService, $this->name, $field);
1150.             if (isset($mapping['enumType']) && $this->reflFields[$field] !== null) {
1151.                 $this->reflFields[$field] = new ReflectionEnumProperty(
1152.                     $this->reflFields[$field],
1153.                     $mapping['enumType']
1154.                 );
1155.             }
1156.         }
1158.         foreach ($this->associationMappings as $field => $mapping) {
1159.             $this->reflFields[$field] = isset($mapping['declared'])
1160.                 ? $this->getAccessibleProperty($reflService, $mapping['declared'], $field)
1161.                 : $this->getAccessibleProperty($reflService, $this->name, $field);
1162.         }
1163.     }
1165.     /**
1166.      * Initializes a new ClassMetadata instance that will hold the object-relational mapping
1167.      * metadata of the class with the given name.
1168.      *
1169.      * @param ReflectionService $reflService The reflection service.
1170.      *
1171.      * @return void
1172.      */
1173.     public function initializeReflection($reflService)
1174.     {
1175.         $this->reflClass = $reflService->getClass($this->name);
1176.         $this->namespace = $reflService->getClassNamespace($this->name);
1178.         if ($this->reflClass) {
1179.             $this->name = $this->rootEntityName = $this->reflClass->name;
1180.         }
1182.         $this->table['name'] = $this->namingStrategy->classToTableName($this->name);
1183.     }
1185.     /**
1186.      * Validates Identifier.
1187.      *
1188.      * @return void
1189.      *
1190.      * @throws MappingException
1191.      */
1192.     public function validateIdentifier()
1193.     {
1194.         if ($this->isMappedSuperclass || $this->isEmbeddedClass) {
1195.             return;
1196.         }
1198.         // Verify & complete identifier mapping
1199.         if (! $this->identifier) {
1200.             throw MappingException::identifierRequired($this->name);
1201.         }
1203.         if ($this->usesIdGenerator() && $this->isIdentifierComposite) {
1204.             throw MappingException::compositeKeyAssignedIdGeneratorRequired($this->name);
1205.         }
1206.     }
1208.     /**
1209.      * Validates association targets actually exist.
1210.      *
1211.      * @return void
1212.      *
1213.      * @throws MappingException
1214.      */
1215.     public function validateAssociations()
1216.     {
1217.         foreach ($this->associationMappings as $mapping) {
1218.             if (
1219.                 ! class_exists($mapping['targetEntity'])
1220.                 && ! interface_exists($mapping['targetEntity'])
1221.                 && ! trait_exists($mapping['targetEntity'])
1222.             ) {
1223.                 throw MappingException::invalidTargetEntityClass($mapping['targetEntity'], $this->name, $mapping['fieldName']);
1224.             }
1225.         }
1226.     }
1228.     /**
1229.      * Validates lifecycle callbacks.
1230.      *
1231.      * @param ReflectionService $reflService
1232.      *
1233.      * @return void
1234.      *
1235.      * @throws MappingException
1236.      */
1237.     public function validateLifecycleCallbacks($reflService)
1238.     {
1239.         foreach ($this->lifecycleCallbacks as $callbacks) {
1240.             foreach ($callbacks as $callbackFuncName) {
1241.                 if (! $reflService->hasPublicMethod($this->name, $callbackFuncName)) {
1242.                     throw MappingException::lifecycleCallbackMethodNotFound($this->name, $callbackFuncName);
1243.                 }
1244.             }
1245.         }
1246.     }
1248.     /**
1249.      * {@inheritDoc}
1250.      */
1251.     public function getReflectionClass()
1252.     {
1253.         return $this->reflClass;
1254.     }
1256.     /**
1257.      * @psalm-param array{usage?: mixed, region?: mixed} $cache
1258.      *
1259.      * @return void
1260.      */
1261.     public function enableCache(array $cache)
1262.     {
1263.         if (! isset($cache['usage'])) {
1264.             $cache['usage'] = self::CACHE_USAGE_READ_ONLY;
1265.         }
1267.         if (! isset($cache['region'])) {
1268.             $cache['region'] = strtolower(str_replace('\\', '_', $this->rootEntityName));
1269.         }
1271.         $this->cache = $cache;
1272.     }
1274.     /**
1275.      * @param string $fieldName
1276.      * @psalm-param array{usage?: int, region?: string} $cache
1277.      *
1278.      * @return void
1279.      */
1280.     public function enableAssociationCache($fieldName, array $cache)
1281.     {
1282.         $this->associationMappings[$fieldName]['cache'] = $this->getAssociationCacheDefaults($fieldName, $cache);
1283.     }
1285.     /**
1286.      * @param string $fieldName
1287.      * @param array  $cache
1288.      * @psalm-param array{usage?: int|null, region?: string|null} $cache
1289.      *
1290.      * @return int[]|string[]
1291.      * @psalm-return array{usage: int, region: string|null}
1292.      */
1293.     public function getAssociationCacheDefaults($fieldName, array $cache)
1294.     {
1295.         if (! isset($cache['usage'])) {
1296.             $cache['usage'] = $this->cache['usage'] ?? self::CACHE_USAGE_READ_ONLY;
1297.         }
1299.         if (! isset($cache['region'])) {
1300.             $cache['region'] = strtolower(str_replace('\\', '_', $this->rootEntityName)) . '__' . $fieldName;
1301.         }
1303.         return $cache;
1304.     }
1306.     /**
1307.      * Sets the change tracking policy used by this class.
1308.      *
1309.      * @param int $policy
1310.      *
1311.      * @return void
1312.      */
1313.     public function setChangeTrackingPolicy($policy)
1314.     {
1315.         $this->changeTrackingPolicy = $policy;
1316.     }
1318.     /**
1319.      * Whether the change tracking policy of this class is "deferred explicit".
1320.      *
1321.      * @return bool
1322.      */
1323.     public function isChangeTrackingDeferredExplicit()
1324.     {
1325.         return $this->changeTrackingPolicy === self::CHANGETRACKING_DEFERRED_EXPLICIT;
1326.     }
1328.     /**
1329.      * Whether the change tracking policy of this class is "deferred implicit".
1330.      *
1331.      * @return bool
1332.      */
1333.     public function isChangeTrackingDeferredImplicit()
1334.     {
1335.         return $this->changeTrackingPolicy === self::CHANGETRACKING_DEFERRED_IMPLICIT;
1336.     }
1338.     /**
1339.      * Whether the change tracking policy of this class is "notify".
1340.      *
1341.      * @return bool
1342.      */
1343.     public function isChangeTrackingNotify()
1344.     {
1345.         return $this->changeTrackingPolicy === self::CHANGETRACKING_NOTIFY;
1346.     }
1348.     /**
1349.      * Checks whether a field is part of the identifier/primary key field(s).
1350.      *
1351.      * @param string $fieldName The field name.
1352.      *
1353.      * @return bool TRUE if the field is part of the table identifier/primary key field(s),
1354.      * FALSE otherwise.
1355.      */
1356.     public function isIdentifier($fieldName)
1357.     {
1358.         if (! $this->identifier) {
1359.             return false;
1360.         }
1362.         if (! $this->isIdentifierComposite) {
1363.             return $fieldName === $this->identifier[0];
1364.         }
1366.         return in_array($fieldName, $this->identifier, true);
1367.     }
1369.     /**
1370.      * Checks if the field is unique.
1371.      *
1372.      * @param string $fieldName The field name.
1373.      *
1374.      * @return bool TRUE if the field is unique, FALSE otherwise.
1375.      */
1376.     public function isUniqueField($fieldName)
1377.     {
1378.         $mapping = $this->getFieldMapping($fieldName);
1380.         return $mapping !== false && isset($mapping['unique']) && $mapping['unique'];
1381.     }
1383.     /**
1384.      * Checks if the field is not null.
1385.      *
1386.      * @param string $fieldName The field name.
1387.      *
1388.      * @return bool TRUE if the field is not null, FALSE otherwise.
1389.      */
1390.     public function isNullable($fieldName)
1391.     {
1392.         $mapping = $this->getFieldMapping($fieldName);
1394.         return $mapping !== false && isset($mapping['nullable']) && $mapping['nullable'];
1395.     }
1397.     /**
1398.      * Gets a column name for a field name.
1399.      * If the column name for the field cannot be found, the given field name
1400.      * is returned.
1401.      *
1402.      * @param string $fieldName The field name.
1403.      *
1404.      * @return string The column name.
1405.      */
1406.     public function getColumnName($fieldName)
1407.     {
1408.         return $this->columnNames[$fieldName] ?? $fieldName;
1409.     }
1411.     /**
1412.      * Gets the mapping of a (regular) field that holds some data but not a
1413.      * reference to another object.
1414.      *
1415.      * @param string $fieldName The field name.
1416.      *
1417.      * @return mixed[] The field mapping.
1418.      * @psalm-return FieldMapping
1419.      *
1420.      * @throws MappingException
1421.      */
1422.     public function getFieldMapping($fieldName)
1423.     {
1424.         if (! isset($this->fieldMappings[$fieldName])) {
1425.             throw MappingException::mappingNotFound($this->name, $fieldName);
1426.         }
1428.         return $this->fieldMappings[$fieldName];
1429.     }
1431.     /**
1432.      * Gets the mapping of an association.
1433.      *
1434.      * @see ClassMetadataInfo::$associationMappings
1435.      *
1436.      * @param string $fieldName The field name that represents the association in
1437.      *                          the object model.
1438.      *
1439.      * @return mixed[] The mapping.
1440.      * @psalm-return AssociationMapping
1441.      *
1442.      * @throws MappingException
1443.      */
1444.     public function getAssociationMapping($fieldName)
1445.     {
1446.         if (! isset($this->associationMappings[$fieldName])) {
1447.             throw MappingException::mappingNotFound($this->name, $fieldName);
1448.         }
1450.         return $this->associationMappings[$fieldName];
1451.     }
1453.     /**
1454.      * Gets all association mappings of the class.
1455.      *
1456.      * @psalm-return array<string, AssociationMapping>
1457.      */
1458.     public function getAssociationMappings()
1459.     {
1460.         return $this->associationMappings;
1461.     }
1463.     /**
1464.      * Gets the field name for a column name.
1465.      * If no field name can be found the column name is returned.
1466.      *
1467.      * @param string $columnName The column name.
1468.      *
1469.      * @return string The column alias.
1470.      */
1471.     public function getFieldName($columnName)
1472.     {
1473.         return $this->fieldNames[$columnName] ?? $columnName;
1474.     }
1476.     /**
1477.      * Gets the named query.
1478.      *
1479.      * @see ClassMetadataInfo::$namedQueries
1480.      *
1481.      * @param string $queryName The query name.
1482.      *
1483.      * @return string
1484.      *
1485.      * @throws MappingException
1486.      */
1487.     public function getNamedQuery($queryName)
1488.     {
1489.         if (! isset($this->namedQueries[$queryName])) {
1490.             throw MappingException::queryNotFound($this->name, $queryName);
1491.         }
1493.         return $this->namedQueries[$queryName]['dql'];
1494.     }
1496.     /**
1497.      * Gets all named queries of the class.
1498.      *
1499.      * @return mixed[][]
1500.      * @psalm-return array<string, array<string, mixed>>
1501.      */
1502.     public function getNamedQueries()
1503.     {
1504.         return $this->namedQueries;
1505.     }
1507.     /**
1508.      * Gets the named native query.
1509.      *
1510.      * @see ClassMetadataInfo::$namedNativeQueries
1511.      *
1512.      * @param string $queryName The query name.
1513.      *
1514.      * @return mixed[]
1515.      * @psalm-return array<string, mixed>
1516.      *
1517.      * @throws MappingException
1518.      */
1519.     public function getNamedNativeQuery($queryName)
1520.     {
1521.         if (! isset($this->namedNativeQueries[$queryName])) {
1522.             throw MappingException::queryNotFound($this->name, $queryName);
1523.         }
1525.         return $this->namedNativeQueries[$queryName];
1526.     }
1528.     /**
1529.      * Gets all named native queries of the class.
1530.      *
1531.      * @psalm-return array<string, array<string, mixed>>
1532.      */
1533.     public function getNamedNativeQueries()
1534.     {
1535.         return $this->namedNativeQueries;
1536.     }
1538.     /**
1539.      * Gets the result set mapping.
1540.      *
1541.      * @see ClassMetadataInfo::$sqlResultSetMappings
1542.      *
1543.      * @param string $name The result set mapping name.
1544.      *
1545.      * @return mixed[]
1546.      * @psalm-return array{name: string, entities: array, columns: array}
1547.      *
1548.      * @throws MappingException
1549.      */
1550.     public function getSqlResultSetMapping($name)
1551.     {
1552.         if (! isset($this->sqlResultSetMappings[$name])) {
1553.             throw MappingException::resultMappingNotFound($this->name, $name);
1554.         }
1556.         return $this->sqlResultSetMappings[$name];
1557.     }
1559.     /**
1560.      * Gets all sql result set mappings of the class.
1561.      *
1562.      * @return mixed[]
1563.      * @psalm-return array<string, array{name: string, entities: array, columns: array}>
1564.      */
1565.     public function getSqlResultSetMappings()
1566.     {
1567.         return $this->sqlResultSetMappings;
1568.     }
1570.     /**
1571.      * Checks whether given property has type
1572.      *
1573.      * @param string $name Property name
1574.      */
1575.     private function isTypedProperty(string $name): bool
1576.     {
1577.         return PHP_VERSION_ID >= 70400
1578.                && isset($this->reflClass)
1579.                && $this->reflClass->hasProperty($name)
1580.                && $this->reflClass->getProperty($name)->hasType();
1581.     }
1583.     /**
1584.      * Validates & completes the given field mapping based on typed property.
1585.      *
1586.      * @param  array{fieldName: string, type?: string} $mapping The field mapping to validate & complete.
1587.      *
1588.      * @return array{fieldName: string, enumType?: class-string<BackedEnum>, type?: string} The updated mapping.
1589.      */
1590.     private function validateAndCompleteTypedFieldMapping(array $mapping): array
1591.     {
1592.         $field = $this->reflClass->getProperty($mapping['fieldName']);
1594.         $mapping = $this->typedFieldMapper->validateAndComplete($mapping, $field);
1596.         return $mapping;
1597.     }
1599.     /**
1600.      * Validates & completes the basic mapping information based on typed property.
1601.      *
1602.      * @param array{type: self::ONE_TO_ONE|self::MANY_TO_ONE|self::ONE_TO_MANY|self::MANY_TO_MANY, fieldName: string, targetEntity?: class-string} $mapping The mapping.
1603.      *
1604.      * @return mixed[] The updated mapping.
1605.      */
1606.     private function validateAndCompleteTypedAssociationMapping(array $mapping): array
1607.     {
1608.         $type = $this->reflClass->getProperty($mapping['fieldName'])->getType();
1610.         if ($type === null || ($mapping['type'] & self::TO_ONE) === 0) {
1611.             return $mapping;
1612.         }
1614.         if (! isset($mapping['targetEntity']) && $type instanceof ReflectionNamedType) {
1615.             $mapping['targetEntity'] = $type->getName();
1616.         }
1618.         return $mapping;
1619.     }
1621.     /**
1622.      * Validates & completes the given field mapping.
1623.      *
1624.      * @psalm-param array{
1625.      *     fieldName?: string,
1626.      *     columnName?: string,
1627.      *     id?: bool,
1628.      *     generated?: int,
1629.      *     enumType?: class-string,
1630.      * } $mapping The field mapping to validate & complete.
1631.      *
1632.      * @return FieldMapping The updated mapping.
1633.      *
1634.      * @throws MappingException
1635.      */
1636.     protected function validateAndCompleteFieldMapping(array $mapping): array
1637.     {
1638.         // Check mandatory fields
1639.         if (! isset($mapping['fieldName']) || ! $mapping['fieldName']) {
1640.             throw MappingException::missingFieldName($this->name);
1641.         }
1643.         if ($this->isTypedProperty($mapping['fieldName'])) {
1644.             $mapping = $this->validateAndCompleteTypedFieldMapping($mapping);
1645.         }
1647.         if (! isset($mapping['type'])) {
1648.             // Default to string
1649.             $mapping['type'] = 'string';
1650.         }
1652.         // Complete fieldName and columnName mapping
1653.         if (! isset($mapping['columnName'])) {
1654.             $mapping['columnName'] = $this->namingStrategy->propertyToColumnName($mapping['fieldName'], $this->name);
1655.         }
1657.         if ($mapping['columnName'][0] === '`') {
1658.             $mapping['columnName'] = trim($mapping['columnName'], '`');
1659.             $mapping['quoted']     = true;
1660.         }
1662.         $this->columnNames[$mapping['fieldName']] = $mapping['columnName'];
1664.         if (isset($this->fieldNames[$mapping['columnName']]) || ($this->discriminatorColumn && $this->discriminatorColumn['name'] === $mapping['columnName'])) {
1665.             throw MappingException::duplicateColumnName($this->name, $mapping['columnName']);
1666.         }
1668.         $this->fieldNames[$mapping['columnName']] = $mapping['fieldName'];
1670.         // Complete id mapping
1671.         if (isset($mapping['id']) && $mapping['id'] === true) {
1672.             if ($this->versionField === $mapping['fieldName']) {
1673.                 throw MappingException::cannotVersionIdField($this->name, $mapping['fieldName']);
1674.             }
1676.             if (! in_array($mapping['fieldName'], $this->identifier, true)) {
1677.                 $this->identifier[] = $mapping['fieldName'];
1678.             }
1680.             // Check for composite key
1681.             if (! $this->isIdentifierComposite && count($this->identifier) > 1) {
1682.                 $this->isIdentifierComposite = true;
1683.             }
1684.         }
1686.         if (Type::hasType($mapping['type']) && Type::getType($mapping['type'])->canRequireSQLConversion()) {
1687.             if (isset($mapping['id']) && $mapping['id'] === true) {
1688.                  throw MappingException::sqlConversionNotAllowedForIdentifiers($this->name, $mapping['fieldName'], $mapping['type']);
1689.             }
1691.             $mapping['requireSQLConversion'] = true;
1692.         }
1694.         if (isset($mapping['generated'])) {
1695.             if (! in_array($mapping['generated'], [self::GENERATED_NEVER, self::GENERATED_INSERT, self::GENERATED_ALWAYS])) {
1696.                 throw MappingException::invalidGeneratedMode($mapping['generated']);
1697.             }
1699.             if ($mapping['generated'] === self::GENERATED_NEVER) {
1700.                 unset($mapping['generated']);
1701.             }
1702.         }
1704.         if (isset($mapping['enumType'])) {
1705.             if (PHP_VERSION_ID < 80100) {
1706.                 throw MappingException::enumsRequirePhp81($this->name, $mapping['fieldName']);
1707.             }
1709.             if (! enum_exists($mapping['enumType'])) {
1710.                 throw MappingException::nonEnumTypeMapped($this->name, $mapping['fieldName'], $mapping['enumType']);
1711.             }
1713.             if (! empty($mapping['id'])) {
1714.                 $this->containsEnumIdentifier = true;
1715.             }
1716.         }
1718.         return $mapping;
1719.     }
1721.     /**
1722.      * Validates & completes the basic mapping information that is common to all
1723.      * association mappings (one-to-one, many-ot-one, one-to-many, many-to-many).
1724.      *
1725.      * @psalm-param array<string, mixed> $mapping The mapping.
1726.      *
1727.      * @return mixed[] The updated mapping.
1728.      * @psalm-return AssociationMapping
1729.      *
1730.      * @throws MappingException If something is wrong with the mapping.
1731.      */
1732.     protected function _validateAndCompleteAssociationMapping(array $mapping)
1733.     {
1734.         if (! isset($mapping['mappedBy'])) {
1735.             $mapping['mappedBy'] = null;
1736.         }
1738.         if (! isset($mapping['inversedBy'])) {
1739.             $mapping['inversedBy'] = null;
1740.         }
1742.         $mapping['isOwningSide'] = true; // assume owning side until we hit mappedBy
1744.         if (empty($mapping['indexBy'])) {
1745.             unset($mapping['indexBy']);
1746.         }
1748.         // If targetEntity is unqualified, assume it is in the same namespace as
1749.         // the sourceEntity.
1750.         $mapping['sourceEntity'] = $this->name;
1752.         if ($this->isTypedProperty($mapping['fieldName'])) {
1753.             $mapping = $this->validateAndCompleteTypedAssociationMapping($mapping);
1754.         }
1756.         if (isset($mapping['targetEntity'])) {
1757.             $mapping['targetEntity'] = $this->fullyQualifiedClassName($mapping['targetEntity']);
1758.             $mapping['targetEntity'] = ltrim($mapping['targetEntity'], '\\');
1759.         }
1761.         if (($mapping['type'] & self::MANY_TO_ONE) > 0 && isset($mapping['orphanRemoval']) && $mapping['orphanRemoval']) {
1762.             throw MappingException::illegalOrphanRemoval($this->name, $mapping['fieldName']);
1763.         }
1765.         // Complete id mapping
1766.         if (isset($mapping['id']) && $mapping['id'] === true) {
1767.             if (isset($mapping['orphanRemoval']) && $mapping['orphanRemoval']) {
1768.                 throw MappingException::illegalOrphanRemovalOnIdentifierAssociation($this->name, $mapping['fieldName']);
1769.             }
1771.             if (! in_array($mapping['fieldName'], $this->identifier, true)) {
1772.                 if (isset($mapping['joinColumns']) && count($mapping['joinColumns']) >= 2) {
1773.                     throw MappingException::cannotMapCompositePrimaryKeyEntitiesAsForeignId(
1774.                         $mapping['targetEntity'],
1775.                         $this->name,
1776.                         $mapping['fieldName']
1777.                     );
1778.                 }
1780.                 $this->identifier[]              = $mapping['fieldName'];
1781.                 $this->containsForeignIdentifier = true;
1782.             }
1784.             // Check for composite key
1785.             if (! $this->isIdentifierComposite && count($this->identifier) > 1) {
1786.                 $this->isIdentifierComposite = true;
1787.             }
1789.             if ($this->cache && ! isset($mapping['cache'])) {
1790.                 throw NonCacheableEntityAssociation::fromEntityAndField(
1791.                     $this->name,
1792.                     $mapping['fieldName']
1793.                 );
1794.             }
1795.         }
1797.         // Mandatory attributes for both sides
1798.         // Mandatory: fieldName, targetEntity
1799.         if (! isset($mapping['fieldName']) || ! $mapping['fieldName']) {
1800.             throw MappingException::missingFieldName($this->name);
1801.         }
1803.         if (! isset($mapping['targetEntity'])) {
1804.             throw MappingException::missingTargetEntity($mapping['fieldName']);
1805.         }
1807.         // Mandatory and optional attributes for either side
1808.         if (! $mapping['mappedBy']) {
1809.             if (isset($mapping['joinTable']) && $mapping['joinTable']) {
1810.                 if (isset($mapping['joinTable']['name']) && $mapping['joinTable']['name'][0] === '`') {
1811.                     $mapping['joinTable']['name']   = trim($mapping['joinTable']['name'], '`');
1812.                     $mapping['joinTable']['quoted'] = true;
1813.                 }
1814.             }
1815.         } else {
1816.             $mapping['isOwningSide'] = false;
1817.         }
1819.         if (isset($mapping['id']) && $mapping['id'] === true && $mapping['type'] & self::TO_MANY) {
1820.             throw MappingException::illegalToManyIdentifierAssociation($this->name, $mapping['fieldName']);
1821.         }
1823.         // Fetch mode. Default fetch mode to LAZY, if not set.
1824.         if (! isset($mapping['fetch'])) {
1825.             $mapping['fetch'] = self::FETCH_LAZY;
1826.         }
1828.         // Cascades
1829.         $cascades = isset($mapping['cascade']) ? array_map('strtolower', $mapping['cascade']) : [];
1831.         $allCascades = ['remove', 'persist', 'refresh', 'merge', 'detach'];
1832.         if (in_array('all', $cascades, true)) {
1833.             $cascades = $allCascades;
1834.         } elseif (count($cascades) !== count(array_intersect($cascades, $allCascades))) {
1835.             throw MappingException::invalidCascadeOption(
1836.                 array_diff($cascades, $allCascades),
1837.                 $this->name,
1838.                 $mapping['fieldName']
1839.             );
1840.         }
1842.         $mapping['cascade']          = $cascades;
1843.         $mapping['isCascadeRemove']  = in_array('remove', $cascades, true);
1844.         $mapping['isCascadePersist'] = in_array('persist', $cascades, true);
1845.         $mapping['isCascadeRefresh'] = in_array('refresh', $cascades, true);
1846.         $mapping['isCascadeMerge']   = in_array('merge', $cascades, true);
1847.         $mapping['isCascadeDetach']  = in_array('detach', $cascades, true);
1849.         return $mapping;
1850.     }
1852.     /**
1853.      * Validates & completes a one-to-one association mapping.
1854.      *
1855.      * @psalm-param array<string, mixed> $mapping The mapping to validate & complete.
1856.      *
1857.      * @return mixed[] The validated & completed mapping.
1858.      * @psalm-return AssociationMapping
1859.      *
1860.      * @throws RuntimeException
1861.      * @throws MappingException
1862.      */
1863.     protected function _validateAndCompleteOneToOneMapping(array $mapping)
1864.     {
1865.         $mapping = $this->_validateAndCompleteAssociationMapping($mapping);
1867.         if (isset($mapping['joinColumns']) && $mapping['joinColumns'] && ! $mapping['isOwningSide']) {
1868.             Deprecation::trigger(
1869.                 'doctrine/orm',
1870.                 'https://github.com/doctrine/orm/pull/10654',
1871.                 'JoinColumn configuration is not allowed on the inverse side of one-to-one associations, and will throw a MappingException in Doctrine ORM 3.0'
1872.             );
1873.         }
1875.         if (isset($mapping['joinColumns']) && $mapping['joinColumns']) {
1876.             $mapping['isOwningSide'] = true;
1877.         }
1879.         if ($mapping['isOwningSide']) {
1880.             if (empty($mapping['joinColumns'])) {
1881.                 // Apply default join column
1882.                 $mapping['joinColumns'] = [
1883.                     [
1884.                         'name' => $this->namingStrategy->joinColumnName($mapping['fieldName'], $this->name),
1885.                         'referencedColumnName' => $this->namingStrategy->referenceColumnName(),
1886.                     ],
1887.                 ];
1888.             }
1890.             $uniqueConstraintColumns = [];
1892.             foreach ($mapping['joinColumns'] as &$joinColumn) {
1893.                 if ($mapping['type'] === self::ONE_TO_ONE && ! $this->isInheritanceTypeSingleTable()) {
1894.                     if (count($mapping['joinColumns']) === 1) {
1895.                         if (empty($mapping['id'])) {
1896.                             $joinColumn['unique'] = true;
1897.                         }
1898.                     } else {
1899.                         $uniqueConstraintColumns[] = $joinColumn['name'];
1900.                     }
1901.                 }
1903.                 if (empty($joinColumn['name'])) {
1904.                     $joinColumn['name'] = $this->namingStrategy->joinColumnName($mapping['fieldName'], $this->name);
1905.                 }
1907.                 if (empty($joinColumn['referencedColumnName'])) {
1908.                     $joinColumn['referencedColumnName'] = $this->namingStrategy->referenceColumnName();
1909.                 }
1911.                 if ($joinColumn['name'][0] === '`') {
1912.                     $joinColumn['name']   = trim($joinColumn['name'], '`');
1913.                     $joinColumn['quoted'] = true;
1914.                 }
1916.                 if ($joinColumn['referencedColumnName'][0] === '`') {
1917.                     $joinColumn['referencedColumnName'] = trim($joinColumn['referencedColumnName'], '`');
1918.                     $joinColumn['quoted']               = true;
1919.                 }
1921.                 $mapping['sourceToTargetKeyColumns'][$joinColumn['name']] = $joinColumn['referencedColumnName'];
1922.                 $mapping['joinColumnFieldNames'][$joinColumn['name']]     = $joinColumn['fieldName'] ?? $joinColumn['name'];
1923.             }
1925.             if ($uniqueConstraintColumns) {
1926.                 if (! $this->table) {
1927.                     throw new RuntimeException('ClassMetadataInfo::setTable() has to be called before defining a one to one relationship.');
1928.                 }
1930.                 $this->table['uniqueConstraints'][$mapping['fieldName'] . '_uniq'] = ['columns' => $uniqueConstraintColumns];
1931.             }
1933.             $mapping['targetToSourceKeyColumns'] = array_flip($mapping['sourceToTargetKeyColumns']);
1934.         }
1936.         $mapping['orphanRemoval']   = isset($mapping['orphanRemoval']) && $mapping['orphanRemoval'];
1937.         $mapping['isCascadeRemove'] = $mapping['orphanRemoval'] || $mapping['isCascadeRemove'];
1939.         if ($mapping['orphanRemoval']) {
1940.             unset($mapping['unique']);
1941.         }
1943.         if (isset($mapping['id']) && $mapping['id'] === true && ! $mapping['isOwningSide']) {
1944.             throw MappingException::illegalInverseIdentifierAssociation($this->name, $mapping['fieldName']);
1945.         }
1947.         return $mapping;
1948.     }
1950.     /**
1951.      * Validates & completes a one-to-many association mapping.
1952.      *
1953.      * @psalm-param array<string, mixed> $mapping The mapping to validate and complete.
1954.      *
1955.      * @return mixed[] The validated and completed mapping.
1956.      * @psalm-return AssociationMapping
1957.      *
1958.      * @throws MappingException
1959.      * @throws InvalidArgumentException
1960.      */
1961.     protected function _validateAndCompleteOneToManyMapping(array $mapping)
1962.     {
1963.         $mapping = $this->_validateAndCompleteAssociationMapping($mapping);
1965.         // OneToMany-side MUST be inverse (must have mappedBy)
1966.         if (! isset($mapping['mappedBy'])) {
1967.             throw MappingException::oneToManyRequiresMappedBy($this->name, $mapping['fieldName']);
1968.         }
1970.         $mapping['orphanRemoval']   = isset($mapping['orphanRemoval']) && $mapping['orphanRemoval'];
1971.         $mapping['isCascadeRemove'] = $mapping['orphanRemoval'] || $mapping['isCascadeRemove'];
1973.         $this->assertMappingOrderBy($mapping);
1975.         return $mapping;
1976.     }
1978.     /**
1979.      * Validates & completes a many-to-many association mapping.
1980.      *
1981.      * @psalm-param array<string, mixed> $mapping The mapping to validate & complete.
1982.      *
1983.      * @return mixed[] The validated & completed mapping.
1984.      * @psalm-return AssociationMapping
1985.      *
1986.      * @throws InvalidArgumentException
1987.      */
1988.     protected function _validateAndCompleteManyToManyMapping(array $mapping)
1989.     {
1990.         $mapping = $this->_validateAndCompleteAssociationMapping($mapping);
1992.         if ($mapping['isOwningSide']) {
1993.             // owning side MUST have a join table
1994.             if (! isset($mapping['joinTable']['name'])) {
1995.                 $mapping['joinTable']['name'] = $this->namingStrategy->joinTableName($mapping['sourceEntity'], $mapping['targetEntity'], $mapping['fieldName']);
1996.             }
1998.             $selfReferencingEntityWithoutJoinColumns = $mapping['sourceEntity'] === $mapping['targetEntity']
1999.                 && (! (isset($mapping['joinTable']['joinColumns']) || isset($mapping['joinTable']['inverseJoinColumns'])));
2001.             if (! isset($mapping['joinTable']['joinColumns'])) {
2002.                 $mapping['joinTable']['joinColumns'] = [
2003.                     [
2004.                         'name' => $this->namingStrategy->joinKeyColumnName($mapping['sourceEntity'], $selfReferencingEntityWithoutJoinColumns ? 'source' : null),
2005.                         'referencedColumnName' => $this->namingStrategy->referenceColumnName(),
2006.                         'onDelete' => 'CASCADE',
2007.                     ],
2008.                 ];
2009.             }
2011.             if (! isset($mapping['joinTable']['inverseJoinColumns'])) {
2012.                 $mapping['joinTable']['inverseJoinColumns'] = [
2013.                     [
2014.                         'name' => $this->namingStrategy->joinKeyColumnName($mapping['targetEntity'], $selfReferencingEntityWithoutJoinColumns ? 'target' : null),
2015.                         'referencedColumnName' => $this->namingStrategy->referenceColumnName(),
2016.                         'onDelete' => 'CASCADE',
2017.                     ],
2018.                 ];
2019.             }
2021.             $mapping['joinTableColumns'] = [];
2023.             foreach ($mapping['joinTable']['joinColumns'] as &$joinColumn) {
2024.                 if (empty($joinColumn['name'])) {
2025.                     $joinColumn['name'] = $this->namingStrategy->joinKeyColumnName($mapping['sourceEntity'], $joinColumn['referencedColumnName']);
2026.                 }
2028.                 if (empty($joinColumn['referencedColumnName'])) {
2029.                     $joinColumn['referencedColumnName'] = $this->namingStrategy->referenceColumnName();
2030.                 }
2032.                 if ($joinColumn['name'][0] === '`') {
2033.                     $joinColumn['name']   = trim($joinColumn['name'], '`');
2034.                     $joinColumn['quoted'] = true;
2035.                 }
2037.                 if ($joinColumn['referencedColumnName'][0] === '`') {
2038.                     $joinColumn['referencedColumnName'] = trim($joinColumn['referencedColumnName'], '`');
2039.                     $joinColumn['quoted']               = true;
2040.                 }
2042.                 if (isset($joinColumn['onDelete']) && strtolower($joinColumn['onDelete']) === 'cascade') {
2043.                     $mapping['isOnDeleteCascade'] = true;
2044.                 }
2046.                 $mapping['relationToSourceKeyColumns'][$joinColumn['name']] = $joinColumn['referencedColumnName'];
2047.                 $mapping['joinTableColumns'][]                              = $joinColumn['name'];
2048.             }
2050.             foreach ($mapping['joinTable']['inverseJoinColumns'] as &$inverseJoinColumn) {
2051.                 if (empty($inverseJoinColumn['name'])) {
2052.                     $inverseJoinColumn['name'] = $this->namingStrategy->joinKeyColumnName($mapping['targetEntity'], $inverseJoinColumn['referencedColumnName']);
2053.                 }
2055.                 if (empty($inverseJoinColumn['referencedColumnName'])) {
2056.                     $inverseJoinColumn['referencedColumnName'] = $this->namingStrategy->referenceColumnName();
2057.                 }
2059.                 if ($inverseJoinColumn['name'][0] === '`') {
2060.                     $inverseJoinColumn['name']   = trim($inverseJoinColumn['name'], '`');
2061.                     $inverseJoinColumn['quoted'] = true;
2062.                 }
2064.                 if ($inverseJoinColumn['referencedColumnName'][0] === '`') {
2065.                     $inverseJoinColumn['referencedColumnName'] = trim($inverseJoinColumn['referencedColumnName'], '`');
2066.                     $inverseJoinColumn['quoted']               = true;
2067.                 }
2069.                 if (isset($inverseJoinColumn['onDelete']) && strtolower($inverseJoinColumn['onDelete']) === 'cascade') {
2070.                     $mapping['isOnDeleteCascade'] = true;
2071.                 }
2073.                 $mapping['relationToTargetKeyColumns'][$inverseJoinColumn['name']] = $inverseJoinColumn['referencedColumnName'];
2074.                 $mapping['joinTableColumns'][]                                     = $inverseJoinColumn['name'];
2075.             }
2076.         }
2078.         $mapping['orphanRemoval'] = isset($mapping['orphanRemoval']) && $mapping['orphanRemoval'];
2080.         $this->assertMappingOrderBy($mapping);
2082.         return $mapping;
2083.     }
2085.     /**
2086.      * {@inheritDoc}
2087.      */
2088.     public function getIdentifierFieldNames()
2089.     {
2090.         return $this->identifier;
2091.     }
2093.     /**
2094.      * Gets the name of the single id field. Note that this only works on
2095.      * entity classes that have a single-field pk.
2096.      *
2097.      * @return string
2098.      *
2099.      * @throws MappingException If the class doesn't have an identifier or it has a composite primary key.
2100.      */
2101.     public function getSingleIdentifierFieldName()
2102.     {
2103.         if ($this->isIdentifierComposite) {
2104.             throw MappingException::singleIdNotAllowedOnCompositePrimaryKey($this->name);
2105.         }
2107.         if (! isset($this->identifier[0])) {
2108.             throw MappingException::noIdDefined($this->name);
2109.         }
2111.         return $this->identifier[0];
2112.     }
2114.     /**
2115.      * Gets the column name of the single id column. Note that this only works on
2116.      * entity classes that have a single-field pk.
2117.      *
2118.      * @return string
2119.      *
2120.      * @throws MappingException If the class doesn't have an identifier or it has a composite primary key.
2121.      */
2122.     public function getSingleIdentifierColumnName()
2123.     {
2124.         return $this->getColumnName($this->getSingleIdentifierFieldName());
2125.     }
2127.     /**
2128.      * INTERNAL:
2129.      * Sets the mapped identifier/primary key fields of this class.
2130.      * Mainly used by the ClassMetadataFactory to assign inherited identifiers.
2131.      *
2132.      * @psalm-param list<mixed> $identifier
2133.      *
2134.      * @return void
2135.      */
2136.     public function setIdentifier(array $identifier)
2137.     {
2138.         $this->identifier            = $identifier;
2139.         $this->isIdentifierComposite = (count($this->identifier) > 1);
2140.     }
2142.     /**
2143.      * {@inheritDoc}
2144.      */
2145.     public function getIdentifier()
2146.     {
2147.         return $this->identifier;
2148.     }
2150.     /**
2151.      * {@inheritDoc}
2152.      */
2153.     public function hasField($fieldName)
2154.     {
2155.         return isset($this->fieldMappings[$fieldName]) || isset($this->embeddedClasses[$fieldName]);
2156.     }
2158.     /**
2159.      * Gets an array containing all the column names.
2160.      *
2161.      * @psalm-param list<string>|null $fieldNames
2162.      *
2163.      * @return mixed[]
2164.      * @psalm-return list<string>
2165.      */
2166.     public function getColumnNames(?array $fieldNames = null)
2167.     {
2168.         if ($fieldNames === null) {
2169.             return array_keys($this->fieldNames);
2170.         }
2172.         return array_values(array_map([$this, 'getColumnName'], $fieldNames));
2173.     }
2175.     /**
2176.      * Returns an array with all the identifier column names.
2177.      *
2178.      * @psalm-return list<string>
2179.      */
2180.     public function getIdentifierColumnNames()
2181.     {
2182.         $columnNames = [];
2184.         foreach ($this->identifier as $idProperty) {
2185.             if (isset($this->fieldMappings[$idProperty])) {
2186.                 $columnNames[] = $this->fieldMappings[$idProperty]['columnName'];
2188.                 continue;
2189.             }
2191.             // Association defined as Id field
2192.             $joinColumns      = $this->associationMappings[$idProperty]['joinColumns'];
2193.             $assocColumnNames = array_map(static function ($joinColumn) {
2194.                 return $joinColumn['name'];
2195.             }, $joinColumns);
2197.             $columnNames = array_merge($columnNames, $assocColumnNames);
2198.         }
2200.         return $columnNames;
2201.     }
2203.     /**
2204.      * Sets the type of Id generator to use for the mapped class.
2205.      *
2206.      * @param int $generatorType
2207.      * @psalm-param self::GENERATOR_TYPE_* $generatorType
2208.      *
2209.      * @return void
2210.      */
2211.     public function setIdGeneratorType($generatorType)
2212.     {
2213.         $this->generatorType = $generatorType;
2214.     }
2216.     /**
2217.      * Checks whether the mapped class uses an Id generator.
2218.      *
2219.      * @return bool TRUE if the mapped class uses an Id generator, FALSE otherwise.
2220.      */
2221.     public function usesIdGenerator()
2222.     {
2223.         return $this->generatorType !== self::GENERATOR_TYPE_NONE;
2224.     }
2226.     /** @return bool */
2227.     public function isInheritanceTypeNone()
2228.     {
2229.         return $this->inheritanceType === self::INHERITANCE_TYPE_NONE;
2230.     }
2232.     /**
2233.      * Checks whether the mapped class uses the JOINED inheritance mapping strategy.
2234.      *
2235.      * @return bool TRUE if the class participates in a JOINED inheritance mapping,
2236.      * FALSE otherwise.
2237.      */
2238.     public function isInheritanceTypeJoined()
2239.     {
2240.         return $this->inheritanceType === self::INHERITANCE_TYPE_JOINED;
2241.     }
2243.     /**
2244.      * Checks whether the mapped class uses the SINGLE_TABLE inheritance mapping strategy.
2245.      *
2246.      * @return bool TRUE if the class participates in a SINGLE_TABLE inheritance mapping,
2247.      * FALSE otherwise.
2248.      */
2249.     public function isInheritanceTypeSingleTable()
2250.     {
2251.         return $this->inheritanceType === self::INHERITANCE_TYPE_SINGLE_TABLE;
2252.     }
2254.     /**
2255.      * Checks whether the mapped class uses the TABLE_PER_CLASS inheritance mapping strategy.
2256.      *
2257.      * @deprecated
2258.      *
2259.      * @return bool TRUE if the class participates in a TABLE_PER_CLASS inheritance mapping,
2260.      * FALSE otherwise.
2261.      */
2262.     public function isInheritanceTypeTablePerClass()
2263.     {
2264.         Deprecation::triggerIfCalledFromOutside(
2265.             'doctrine/orm',
2266.             'https://github.com/doctrine/orm/pull/10414/',
2267.             'Concrete table inheritance has never been implemented, and its stubs will be removed in Doctrine ORM 3.0 with no replacement'
2268.         );
2270.         return $this->inheritanceType === self::INHERITANCE_TYPE_TABLE_PER_CLASS;
2271.     }
2273.     /**
2274.      * Checks whether the class uses an identity column for the Id generation.
2275.      *
2276.      * @return bool TRUE if the class uses the IDENTITY generator, FALSE otherwise.
2277.      */
2278.     public function isIdGeneratorIdentity()
2279.     {
2280.         return $this->generatorType === self::GENERATOR_TYPE_IDENTITY;
2281.     }
2283.     /**
2284.      * Checks whether the class uses a sequence for id generation.
2285.      *
2286.      * @return bool TRUE if the class uses the SEQUENCE generator, FALSE otherwise.
2287.      *
2288.      * @psalm-assert-if-true !null $this->sequenceGeneratorDefinition
2289.      */
2290.     public function isIdGeneratorSequence()
2291.     {
2292.         return $this->generatorType === self::GENERATOR_TYPE_SEQUENCE;
2293.     }
2295.     /**
2296.      * Checks whether the class uses a table for id generation.
2297.      *
2298.      * @deprecated
2299.      *
2300.      * @return false
2301.      */
2302.     public function isIdGeneratorTable()
2303.     {
2304.         Deprecation::trigger(
2305.             'doctrine/orm',
2306.             'https://github.com/doctrine/orm/pull/9046',
2307.             '%s is deprecated',
2308.             __METHOD__
2309.         );
2311.         return false;
2312.     }
2314.     /**
2315.      * Checks whether the class has a natural identifier/pk (which means it does
2316.      * not use any Id generator.
2317.      *
2318.      * @return bool
2319.      */
2320.     public function isIdentifierNatural()
2321.     {
2322.         return $this->generatorType === self::GENERATOR_TYPE_NONE;
2323.     }
2325.     /**
2326.      * Checks whether the class use a UUID for id generation.
2327.      *
2328.      * @deprecated
2329.      *
2330.      * @return bool
2331.      */
2332.     public function isIdentifierUuid()
2333.     {
2334.         Deprecation::trigger(
2335.             'doctrine/orm',
2336.             'https://github.com/doctrine/orm/pull/9046',
2337.             '%s is deprecated',
2338.             __METHOD__
2339.         );
2341.         return $this->generatorType === self::GENERATOR_TYPE_UUID;
2342.     }
2344.     /**
2345.      * Gets the type of a field.
2346.      *
2347.      * @param string $fieldName
2348.      *
2349.      * @return string|null
2350.      *
2351.      * @todo 3.0 Remove this. PersisterHelper should fix it somehow
2352.      */
2353.     public function getTypeOfField($fieldName)
2354.     {
2355.         return isset($this->fieldMappings[$fieldName])
2356.             ? $this->fieldMappings[$fieldName]['type']
2357.             : null;
2358.     }
2360.     /**
2361.      * Gets the type of a column.
2362.      *
2363.      * @deprecated 3.0 remove this. this method is bogus and unreliable, since it cannot resolve the type of a column
2364.      *             that is derived by a referenced field on a different entity.
2365.      *
2366.      * @param string $columnName
2367.      *
2368.      * @return string|null
2369.      */
2370.     public function getTypeOfColumn($columnName)
2371.     {
2372.         return $this->getTypeOfField($this->getFieldName($columnName));
2373.     }
2375.     /**
2376.      * Gets the name of the primary table.
2377.      *
2378.      * @return string
2379.      */
2380.     public function getTableName()
2381.     {
2382.         return $this->table['name'];
2383.     }
2385.     /**
2386.      * Gets primary table's schema name.
2387.      *
2388.      * @return string|null
2389.      */
2390.     public function getSchemaName()
2391.     {
2392.         return $this->table['schema'] ?? null;
2393.     }
2395.     /**
2396.      * Gets the table name to use for temporary identifier tables of this class.
2397.      *
2398.      * @return string
2399.      */
2400.     public function getTemporaryIdTableName()
2401.     {
2402.         // replace dots with underscores because PostgreSQL creates temporary tables in a special schema
2403.         return str_replace('.', '_', $this->getTableName() . '_id_tmp');
2404.     }
2406.     /**
2407.      * Sets the mapped subclasses of this class.
2408.      *
2409.      * @psalm-param list<string> $subclasses The names of all mapped subclasses.
2410.      *
2411.      * @return void
2412.      */
2413.     public function setSubclasses(array $subclasses)
2414.     {
2415.         foreach ($subclasses as $subclass) {
2416.             $this->subClasses[] = $this->fullyQualifiedClassName($subclass);
2417.         }
2418.     }
2420.     /**
2421.      * Sets the parent class names. Only <em>entity</em> classes may be given.
2422.      *
2423.      * Assumes that the class names in the passed array are in the order:
2424.      * directParent -> directParentParent -> directParentParentParent ... -> root.
2425.      *
2426.      * @psalm-param list<class-string> $classNames
2427.      *
2428.      * @return void
2429.      */
2430.     public function setParentClasses(array $classNames)
2431.     {
2432.         $this->parentClasses = $classNames;
2434.         if (count($classNames) > 0) {
2435.             $this->rootEntityName = array_pop($classNames);
2436.         }
2437.     }
2439.     /**
2440.      * Sets the inheritance type used by the class and its subclasses.
2441.      *
2442.      * @param int $type
2443.      * @psalm-param self::INHERITANCE_TYPE_* $type
2444.      *
2445.      * @return void
2446.      *
2447.      * @throws MappingException
2448.      */
2449.     public function setInheritanceType($type)
2450.     {
2451.         if (! $this->isInheritanceType($type)) {
2452.             throw MappingException::invalidInheritanceType($this->name, $type);
2453.         }
2455.         $this->inheritanceType = $type;
2456.     }
2458.     /**
2459.      * Sets the association to override association mapping of property for an entity relationship.
2460.      *
2461.      * @param string $fieldName
2462.      * @psalm-param array<string, mixed> $overrideMapping
2463.      *
2464.      * @return void
2465.      *
2466.      * @throws MappingException
2467.      */
2468.     public function setAssociationOverride($fieldName, array $overrideMapping)
2469.     {
2470.         if (! isset($this->associationMappings[$fieldName])) {
2471.             throw MappingException::invalidOverrideFieldName($this->name, $fieldName);
2472.         }
2474.         $mapping = $this->associationMappings[$fieldName];
2476.         if (isset($mapping['inherited'])) {
2477.             Deprecation::trigger(
2478.                 'doctrine/orm',
2479.                 'https://github.com/doctrine/orm/pull/10470',
2480.                 'Overrides are only allowed for fields or associations declared in mapped superclasses or traits. This is not the case for %s::%s, which was inherited from %s. This is a misconfiguration and will be an error in Doctrine ORM 3.0.',
2481.                 $this->name,
2482.                 $fieldName,
2483.                 $mapping['inherited']
2484.             );
2485.         }
2487.         if (isset($overrideMapping['joinColumns'])) {
2488.             $mapping['joinColumns'] = $overrideMapping['joinColumns'];
2489.         }
2491.         if (isset($overrideMapping['inversedBy'])) {
2492.             $mapping['inversedBy'] = $overrideMapping['inversedBy'];
2493.         }
2495.         if (isset($overrideMapping['joinTable'])) {
2496.             $mapping['joinTable'] = $overrideMapping['joinTable'];
2497.         }
2499.         if (isset($overrideMapping['fetch'])) {
2500.             $mapping['fetch'] = $overrideMapping['fetch'];
2501.         }
2503.         $mapping['joinColumnFieldNames']       = null;
2504.         $mapping['joinTableColumns']           = null;
2505.         $mapping['sourceToTargetKeyColumns']   = null;
2506.         $mapping['relationToSourceKeyColumns'] = null;
2507.         $mapping['relationToTargetKeyColumns'] = null;
2509.         switch ($mapping['type']) {
2510.             case self::ONE_TO_ONE:
2511.                 $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
2512.                 break;
2513.             case self::ONE_TO_MANY:
2514.                 $mapping = $this->_validateAndCompleteOneToManyMapping($mapping);
2515.                 break;
2516.             case self::MANY_TO_ONE:
2517.                 $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
2518.                 break;
2519.             case self::MANY_TO_MANY:
2520.                 $mapping = $this->_validateAndCompleteManyToManyMapping($mapping);
2521.                 break;
2522.         }
2524.         $this->associationMappings[$fieldName] = $mapping;
2525.     }
2527.     /**
2528.      * Sets the override for a mapped field.
2529.      *
2530.      * @param string $fieldName
2531.      * @psalm-param array<string, mixed> $overrideMapping
2532.      *
2533.      * @return void
2534.      *
2535.      * @throws MappingException
2536.      */
2537.     public function setAttributeOverride($fieldName, array $overrideMapping)
2538.     {
2539.         if (! isset($this->fieldMappings[$fieldName])) {
2540.             throw MappingException::invalidOverrideFieldName($this->name, $fieldName);
2541.         }
2543.         $mapping = $this->fieldMappings[$fieldName];
2545.         if (isset($mapping['inherited'])) {
2546.             Deprecation::trigger(
2547.                 'doctrine/orm',
2548.                 'https://github.com/doctrine/orm/pull/10470',
2549.                 'Overrides are only allowed for fields or associations declared in mapped superclasses or traits. This is not the case for %s::%s, which was inherited from %s. This is a misconfiguration and will be an error in Doctrine ORM 3.0.',
2550.                 $this->name,
2551.                 $fieldName,
2552.                 $mapping['inherited']
2553.             );
2554.             //throw MappingException::illegalOverrideOfInheritedProperty($this->name, $fieldName);
2555.         }
2557.         if (isset($mapping['id'])) {
2558.             $overrideMapping['id'] = $mapping['id'];
2559.         }
2561.         if (! isset($overrideMapping['type'])) {
2562.             $overrideMapping['type'] = $mapping['type'];
2563.         }
2565.         if (! isset($overrideMapping['fieldName'])) {
2566.             $overrideMapping['fieldName'] = $mapping['fieldName'];
2567.         }
2569.         if ($overrideMapping['type'] !== $mapping['type']) {
2570.             throw MappingException::invalidOverrideFieldType($this->name, $fieldName);
2571.         }
2573.         unset($this->fieldMappings[$fieldName]);
2574.         unset($this->fieldNames[$mapping['columnName']]);
2575.         unset($this->columnNames[$mapping['fieldName']]);
2577.         $overrideMapping = $this->validateAndCompleteFieldMapping($overrideMapping);
2579.         $this->fieldMappings[$fieldName] = $overrideMapping;
2580.     }
2582.     /**
2583.      * Checks whether a mapped field is inherited from an entity superclass.
2584.      *
2585.      * @param string $fieldName
2586.      *
2587.      * @return bool TRUE if the field is inherited, FALSE otherwise.
2588.      */
2589.     public function isInheritedField($fieldName)
2590.     {
2591.         return isset($this->fieldMappings[$fieldName]['inherited']);
2592.     }
2594.     /**
2595.      * Checks if this entity is the root in any entity-inheritance-hierarchy.
2596.      *
2597.      * @return bool
2598.      */
2599.     public function isRootEntity()
2600.     {
2601.         return $this->name === $this->rootEntityName;
2602.     }
2604.     /**
2605.      * Checks whether a mapped association field is inherited from a superclass.
2606.      *
2607.      * @param string $fieldName
2608.      *
2609.      * @return bool TRUE if the field is inherited, FALSE otherwise.
2610.      */
2611.     public function isInheritedAssociation($fieldName)
2612.     {
2613.         return isset($this->associationMappings[$fieldName]['inherited']);
2614.     }
2616.     /**
2617.      * @param string $fieldName
2618.      *
2619.      * @return bool
2620.      */
2621.     public function isInheritedEmbeddedClass($fieldName)
2622.     {
2623.         return isset($this->embeddedClasses[$fieldName]['inherited']);
2624.     }
2626.     /**
2627.      * Sets the name of the primary table the class is mapped to.
2628.      *
2629.      * @deprecated Use {@link setPrimaryTable}.
2630.      *
2631.      * @param string $tableName The table name.
2632.      *
2633.      * @return void
2634.      */
2635.     public function setTableName($tableName)
2636.     {
2637.         $this->table['name'] = $tableName;
2638.     }
2640.     /**
2641.      * Sets the primary table definition. The provided array supports the
2642.      * following structure:
2643.      *
2644.      * name => <tableName> (optional, defaults to class name)
2645.      * indexes => array of indexes (optional)
2646.      * uniqueConstraints => array of constraints (optional)
2647.      *
2648.      * If a key is omitted, the current value is kept.
2649.      *
2650.      * @psalm-param array<string, mixed> $table The table description.
2651.      *
2652.      * @return void
2653.      */
2654.     public function setPrimaryTable(array $table)
2655.     {
2656.         if (isset($table['name'])) {
2657.             // Split schema and table name from a table name like "myschema.mytable"
2658.             if (str_contains($table['name'], '.')) {
2659.                 [$this->table['schema'], $table['name']] = explode('.', $table['name'], 2);
2660.             }
2662.             if ($table['name'][0] === '`') {
2663.                 $table['name']         = trim($table['name'], '`');
2664.                 $this->table['quoted'] = true;
2665.             }
2667.             $this->table['name'] = $table['name'];
2668.         }
2670.         if (isset($table['quoted'])) {
2671.             $this->table['quoted'] = $table['quoted'];
2672.         }
2674.         if (isset($table['schema'])) {
2675.             $this->table['schema'] = $table['schema'];
2676.         }
2678.         if (isset($table['indexes'])) {
2679.             $this->table['indexes'] = $table['indexes'];
2680.         }
2682.         if (isset($table['uniqueConstraints'])) {
2683.             $this->table['uniqueConstraints'] = $table['uniqueConstraints'];
2684.         }
2686.         if (isset($table['options'])) {
2687.             $this->table['options'] = $table['options'];
2688.         }
2689.     }
2691.     /**
2692.      * Checks whether the given type identifies an inheritance type.
2693.      *
2694.      * @return bool TRUE if the given type identifies an inheritance type, FALSE otherwise.
2695.      */
2696.     private function isInheritanceType(int $type): bool
2697.     {
2698.         if ($type === self::INHERITANCE_TYPE_TABLE_PER_CLASS) {
2699.             Deprecation::trigger(
2700.                 'doctrine/orm',
2701.                 'https://github.com/doctrine/orm/pull/10414/',
2702.                 'Concrete table inheritance has never been implemented, and its stubs will be removed in Doctrine ORM 3.0 with no replacement'
2703.             );
2704.         }
2706.         return $type === self::INHERITANCE_TYPE_NONE ||
2707.                 $type === self::INHERITANCE_TYPE_SINGLE_TABLE ||
2708.                 $type === self::INHERITANCE_TYPE_JOINED ||
2709.                 $type === self::INHERITANCE_TYPE_TABLE_PER_CLASS;
2710.     }
2712.     /**
2713.      * Adds a mapped field to the class.
2714.      *
2715.      * @psalm-param array<string, mixed> $mapping The field mapping.
2716.      *
2717.      * @return void
2718.      *
2719.      * @throws MappingException
2720.      */
2721.     public function mapField(array $mapping)
2722.     {
2723.         $mapping = $this->validateAndCompleteFieldMapping($mapping);
2724.         $this->assertFieldNotMapped($mapping['fieldName']);
2726.         if (isset($mapping['generated'])) {
2727.             $this->requiresFetchAfterChange = true;
2728.         }
2730.         $this->fieldMappings[$mapping['fieldName']] = $mapping;
2731.     }
2733.     /**
2734.      * INTERNAL:
2735.      * Adds an association mapping without completing/validating it.
2736.      * This is mainly used to add inherited association mappings to derived classes.
2737.      *
2738.      * @psalm-param AssociationMapping $mapping
2739.      *
2740.      * @return void
2741.      *
2742.      * @throws MappingException
2743.      */
2744.     public function addInheritedAssociationMapping(array $mapping/*, $owningClassName = null*/)
2745.     {
2746.         if (isset($this->associationMappings[$mapping['fieldName']])) {
2747.             throw MappingException::duplicateAssociationMapping($this->name, $mapping['fieldName']);
2748.         }
2750.         $this->associationMappings[$mapping['fieldName']] = $mapping;
2751.     }
2753.     /**
2754.      * INTERNAL:
2755.      * Adds a field mapping without completing/validating it.
2756.      * This is mainly used to add inherited field mappings to derived classes.
2757.      *
2758.      * @psalm-param FieldMapping $fieldMapping
2759.      *
2760.      * @return void
2761.      */
2762.     public function addInheritedFieldMapping(array $fieldMapping)
2763.     {
2764.         $this->fieldMappings[$fieldMapping['fieldName']] = $fieldMapping;
2765.         $this->columnNames[$fieldMapping['fieldName']]   = $fieldMapping['columnName'];
2766.         $this->fieldNames[$fieldMapping['columnName']]   = $fieldMapping['fieldName'];
2768.         if (isset($fieldMapping['generated'])) {
2769.             $this->requiresFetchAfterChange = true;
2770.         }
2771.     }
2773.     /**
2774.      * INTERNAL:
2775.      * Adds a named query to this class.
2776.      *
2777.      * @deprecated
2778.      *
2779.      * @psalm-param array<string, mixed> $queryMapping
2780.      *
2781.      * @return void
2782.      *
2783.      * @throws MappingException
2784.      */
2785.     public function addNamedQuery(array $queryMapping)
2786.     {
2787.         if (! isset($queryMapping['name'])) {
2788.             throw MappingException::nameIsMandatoryForQueryMapping($this->name);
2789.         }
2791.         Deprecation::trigger(
2792.             'doctrine/orm',
2793.             'https://github.com/doctrine/orm/issues/8592',
2794.             'Named Queries are deprecated, here "%s" on entity %s. Move the query logic into EntityRepository',
2795.             $queryMapping['name'],
2796.             $this->name
2797.         );
2799.         if (isset($this->namedQueries[$queryMapping['name']])) {
2800.             throw MappingException::duplicateQueryMapping($this->name, $queryMapping['name']);
2801.         }
2803.         if (! isset($queryMapping['query'])) {
2804.             throw MappingException::emptyQueryMapping($this->name, $queryMapping['name']);
2805.         }
2807.         $name  = $queryMapping['name'];
2808.         $query = $queryMapping['query'];
2809.         $dql   = str_replace('__CLASS__', $this->name, $query);
2811.         $this->namedQueries[$name] = [
2812.             'name'  => $name,
2813.             'query' => $query,
2814.             'dql'   => $dql,
2815.         ];
2816.     }
2818.     /**
2819.      * INTERNAL:
2820.      * Adds a named native query to this class.
2821.      *
2822.      * @deprecated
2823.      *
2824.      * @psalm-param array<string, mixed> $queryMapping
2825.      *
2826.      * @return void
2827.      *
2828.      * @throws MappingException
2829.      */
2830.     public function addNamedNativeQuery(array $queryMapping)
2831.     {
2832.         if (! isset($queryMapping['name'])) {
2833.             throw MappingException::nameIsMandatoryForQueryMapping($this->name);
2834.         }
2836.         Deprecation::trigger(
2837.             'doctrine/orm',
2838.             'https://github.com/doctrine/orm/issues/8592',
2839.             'Named Native Queries are deprecated, here "%s" on entity %s. Move the query logic into EntityRepository',
2840.             $queryMapping['name'],
2841.             $this->name
2842.         );
2844.         if (isset($this->namedNativeQueries[$queryMapping['name']])) {
2845.             throw MappingException::duplicateQueryMapping($this->name, $queryMapping['name']);
2846.         }
2848.         if (! isset($queryMapping['query'])) {
2849.             throw MappingException::emptyQueryMapping($this->name, $queryMapping['name']);
2850.         }
2852.         if (! isset($queryMapping['resultClass']) && ! isset($queryMapping['resultSetMapping'])) {
2853.             throw MappingException::missingQueryMapping($this->name, $queryMapping['name']);
2854.         }
2856.         $queryMapping['isSelfClass'] = false;
2858.         if (isset($queryMapping['resultClass'])) {
2859.             if ($queryMapping['resultClass'] === '__CLASS__') {
2860.                 $queryMapping['isSelfClass'] = true;
2861.                 $queryMapping['resultClass'] = $this->name;
2862.             }
2864.             $queryMapping['resultClass'] = $this->fullyQualifiedClassName($queryMapping['resultClass']);
2865.             $queryMapping['resultClass'] = ltrim($queryMapping['resultClass'], '\\');
2866.         }
2868.         $this->namedNativeQueries[$queryMapping['name']] = $queryMapping;
2869.     }
2871.     /**
2872.      * INTERNAL:
2873.      * Adds a sql result set mapping to this class.
2874.      *
2875.      * @psalm-param array<string, mixed> $resultMapping
2876.      *
2877.      * @return void
2878.      *
2879.      * @throws MappingException
2880.      */
2881.     public function addSqlResultSetMapping(array $resultMapping)
2882.     {
2883.         if (! isset($resultMapping['name'])) {
2884.             throw MappingException::nameIsMandatoryForSqlResultSetMapping($this->name);
2885.         }
2887.         if (isset($this->sqlResultSetMappings[$resultMapping['name']])) {
2888.             throw MappingException::duplicateResultSetMapping($this->name, $resultMapping['name']);
2889.         }
2891.         if (isset($resultMapping['entities'])) {
2892.             foreach ($resultMapping['entities'] as $key => $entityResult) {
2893.                 if (! isset($entityResult['entityClass'])) {
2894.                     throw MappingException::missingResultSetMappingEntity($this->name, $resultMapping['name']);
2895.                 }
2897.                 $entityResult['isSelfClass'] = false;
2898.                 if ($entityResult['entityClass'] === '__CLASS__') {
2899.                     $entityResult['isSelfClass'] = true;
2900.                     $entityResult['entityClass'] = $this->name;
2901.                 }
2903.                 $entityResult['entityClass'] = $this->fullyQualifiedClassName($entityResult['entityClass']);
2905.                 $resultMapping['entities'][$key]['entityClass'] = ltrim($entityResult['entityClass'], '\\');
2906.                 $resultMapping['entities'][$key]['isSelfClass'] = $entityResult['isSelfClass'];
2908.                 if (isset($entityResult['fields'])) {
2909.                     foreach ($entityResult['fields'] as $k => $field) {
2910.                         if (! isset($field['name'])) {
2911.                             throw MappingException::missingResultSetMappingFieldName($this->name, $resultMapping['name']);
2912.                         }
2914.                         if (! isset($field['column'])) {
2915.                             $fieldName = $field['name'];
2916.                             if (str_contains($fieldName, '.')) {
2917.                                 [, $fieldName] = explode('.', $fieldName);
2918.                             }
2920.                             $resultMapping['entities'][$key]['fields'][$k]['column'] = $fieldName;
2921.                         }
2922.                     }
2923.                 }
2924.             }
2925.         }
2927.         $this->sqlResultSetMappings[$resultMapping['name']] = $resultMapping;
2928.     }
2930.     /**
2931.      * Adds a one-to-one mapping.
2932.      *
2933.      * @param array<string, mixed> $mapping The mapping.
2934.      *
2935.      * @return void
2936.      */
2937.     public function mapOneToOne(array $mapping)
2938.     {
2939.         $mapping['type'] = self::ONE_TO_ONE;
2941.         $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
2943.         $this->_storeAssociationMapping($mapping);
2944.     }
2946.     /**
2947.      * Adds a one-to-many mapping.
2948.      *
2949.      * @psalm-param array<string, mixed> $mapping The mapping.
2950.      *
2951.      * @return void
2952.      */
2953.     public function mapOneToMany(array $mapping)
2954.     {
2955.         $mapping['type'] = self::ONE_TO_MANY;
2957.         $mapping = $this->_validateAndCompleteOneToManyMapping($mapping);
2959.         $this->_storeAssociationMapping($mapping);
2960.     }
2962.     /**
2963.      * Adds a many-to-one mapping.
2964.      *
2965.      * @psalm-param array<string, mixed> $mapping The mapping.
2966.      *
2967.      * @return void
2968.      */
2969.     public function mapManyToOne(array $mapping)
2970.     {
2971.         $mapping['type'] = self::MANY_TO_ONE;
2973.         // A many-to-one mapping is essentially a one-one backreference
2974.         $mapping = $this->_validateAndCompleteOneToOneMapping($mapping);
2976.         $this->_storeAssociationMapping($mapping);
2977.     }
2979.     /**
2980.      * Adds a many-to-many mapping.
2981.      *
2982.      * @psalm-param array<string, mixed> $mapping The mapping.
2983.      *
2984.      * @return void
2985.      */
2986.     public function mapManyToMany(array $mapping)
2987.     {
2988.         $mapping['type'] = self::MANY_TO_MANY;
2990.         $mapping = $this->_validateAndCompleteManyToManyMapping($mapping);
2992.         $this->_storeAssociationMapping($mapping);
2993.     }
2995.     /**
2996.      * Stores the association mapping.
2997.      *
2998.      * @psalm-param AssociationMapping $assocMapping
2999.      *
3000.      * @return void
3001.      *
3002.      * @throws MappingException
3003.      */
3004.     protected function _storeAssociationMapping(array $assocMapping)
3005.     {
3006.         $sourceFieldName = $assocMapping['fieldName'];
3008.         $this->assertFieldNotMapped($sourceFieldName);
3010.         $this->associationMappings[$sourceFieldName] = $assocMapping;
3011.     }
3013.     /**
3014.      * Registers a custom repository class for the entity class.
3015.      *
3016.      * @param string|null $repositoryClassName The class name of the custom mapper.
3017.      * @psalm-param class-string<EntityRepository>|null $repositoryClassName
3018.      *
3019.      * @return void
3020.      */
3021.     public function setCustomRepositoryClass($repositoryClassName)
3022.     {
3023.         $this->customRepositoryClassName = $this->fullyQualifiedClassName($repositoryClassName);
3024.     }
3026.     /**
3027.      * Dispatches the lifecycle event of the given entity to the registered
3028.      * lifecycle callbacks and lifecycle listeners.
3029.      *
3030.      * @deprecated Deprecated since version 2.4 in favor of \Doctrine\ORM\Event\ListenersInvoker
3031.      *
3032.      * @param string $lifecycleEvent The lifecycle event.
3033.      * @param object $entity         The Entity on which the event occurred.
3034.      *
3035.      * @return void
3036.      */
3037.     public function invokeLifecycleCallbacks($lifecycleEvent, $entity)
3038.     {
3039.         foreach ($this->lifecycleCallbacks[$lifecycleEvent] as $callback) {
3040.             $entity->$callback();
3041.         }
3042.     }
3044.     /**
3045.      * Whether the class has any attached lifecycle listeners or callbacks for a lifecycle event.
3046.      *
3047.      * @param string $lifecycleEvent
3048.      *
3049.      * @return bool
3050.      */
3051.     public function hasLifecycleCallbacks($lifecycleEvent)
3052.     {
3053.         return isset($this->lifecycleCallbacks[$lifecycleEvent]);
3054.     }
3056.     /**
3057.      * Gets the registered lifecycle callbacks for an event.
3058.      *
3059.      * @param string $event
3060.      *
3061.      * @return string[]
3062.      * @psalm-return list<string>
3063.      */
3064.     public function getLifecycleCallbacks($event)
3065.     {
3066.         return $this->lifecycleCallbacks[$event] ?? [];
3067.     }
3069.     /**
3070.      * Adds a lifecycle callback for entities of this class.
3071.      *
3072.      * @param string $callback
3073.      * @param string $event
3074.      *
3075.      * @return void
3076.      */
3077.     public function addLifecycleCallback($callback, $event)
3078.     {
3079.         if ($this->isEmbeddedClass) {
3080.             Deprecation::trigger(
3081.                 'doctrine/orm',
3082.                 'https://github.com/doctrine/orm/pull/8381',
3083.                 'Registering lifecycle callback %s on Embedded class %s is not doing anything and will throw exception in 3.0',
3084.                 $event,
3085.                 $this->name
3086.             );
3087.         }
3089.         if (isset($this->lifecycleCallbacks[$event]) && in_array($callback, $this->lifecycleCallbacks[$event], true)) {
3090.             return;
3091.         }
3093.         $this->lifecycleCallbacks[$event][] = $callback;
3094.     }
3096.     /**
3097.      * Sets the lifecycle callbacks for entities of this class.
3098.      * Any previously registered callbacks are overwritten.
3099.      *
3100.      * @psalm-param array<string, list<string>> $callbacks
3101.      *
3102.      * @return void
3103.      */
3104.     public function setLifecycleCallbacks(array $callbacks)
3105.     {
3106.         $this->lifecycleCallbacks = $callbacks;
3107.     }
3109.     /**
3110.      * Adds a entity listener for entities of this class.
3111.      *
3112.      * @param string $eventName The entity lifecycle event.
3113.      * @param string $class     The listener class.
3114.      * @param string $method    The listener callback method.
3115.      *
3116.      * @return void
3117.      *
3118.      * @throws MappingException
3119.      */
3120.     public function addEntityListener($eventName, $class, $method)
3121.     {
3122.         $class = $this->fullyQualifiedClassName($class);
3124.         $listener = [
3125.             'class'  => $class,
3126.             'method' => $method,
3127.         ];
3129.         if (! class_exists($class)) {
3130.             throw MappingException::entityListenerClassNotFound($class, $this->name);
3131.         }
3133.         if (! method_exists($class, $method)) {
3134.             throw MappingException::entityListenerMethodNotFound($class, $method, $this->name);
3135.         }
3137.         if (isset($this->entityListeners[$eventName]) && in_array($listener, $this->entityListeners[$eventName], true)) {
3138.             throw MappingException::duplicateEntityListener($class, $method, $this->name);
3139.         }
3141.         $this->entityListeners[$eventName][] = $listener;
3142.     }
3144.     /**
3145.      * Sets the discriminator column definition.
3146.      *
3147.      * @see getDiscriminatorColumn()
3148.      *
3149.      * @param mixed[]|null $columnDef
3150.      * @psalm-param array{name: string|null, fieldName?: string, type?: string, length?: int, columnDefinition?: string|null, enumType?: class-string<BackedEnum>|null, options?: array<string, mixed>}|null $columnDef
3151.      *
3152.      * @return void
3153.      *
3154.      * @throws MappingException
3155.      */
3156.     public function setDiscriminatorColumn($columnDef)
3157.     {
3158.         if ($columnDef !== null) {
3159.             if (! isset($columnDef['name'])) {
3160.                 throw MappingException::nameIsMandatoryForDiscriminatorColumns($this->name);
3161.             }
3163.             if (isset($this->fieldNames[$columnDef['name']])) {
3164.                 throw MappingException::duplicateColumnName($this->name, $columnDef['name']);
3165.             }
3167.             if (! isset($columnDef['fieldName'])) {
3168.                 $columnDef['fieldName'] = $columnDef['name'];
3169.             }
3171.             if (! isset($columnDef['type'])) {
3172.                 $columnDef['type'] = 'string';
3173.             }
3175.             if (in_array($columnDef['type'], ['boolean', 'array', 'object', 'datetime', 'time', 'date'], true)) {
3176.                 throw MappingException::invalidDiscriminatorColumnType($this->name, $columnDef['type']);
3177.             }
3179.             $this->discriminatorColumn = $columnDef;
3180.         }
3181.     }
3183.     /**
3184.      * @return array<string, mixed>
3185.      * @psalm-return DiscriminatorColumnMapping
3186.      */
3187.     final public function getDiscriminatorColumn(): array
3188.     {
3189.         if ($this->discriminatorColumn === null) {
3190.             throw new LogicException('The discriminator column was not set.');
3191.         }
3193.         return $this->discriminatorColumn;
3194.     }
3196.     /**
3197.      * Sets the discriminator values used by this class.
3198.      * Used for JOINED and SINGLE_TABLE inheritance mapping strategies.
3199.      *
3200.      * @param array<int|string, string> $map
3201.      *
3202.      * @return void
3203.      */
3204.     public function setDiscriminatorMap(array $map)
3205.     {
3206.         foreach ($map as $value => $className) {
3207.             $this->addDiscriminatorMapClass($value, $className);
3208.         }
3209.     }
3211.     /**
3212.      * Adds one entry of the discriminator map with a new class and corresponding name.
3213.      *
3214.      * @param int|string $name
3215.      * @param string     $className
3216.      *
3217.      * @return void
3218.      *
3219.      * @throws MappingException
3220.      */
3221.     public function addDiscriminatorMapClass($name, $className)
3222.     {
3223.         $className = $this->fullyQualifiedClassName($className);
3224.         $className = ltrim($className, '\\');
3226.         $this->discriminatorMap[$name] = $className;
3228.         if ($this->name === $className) {
3229.             $this->discriminatorValue = $name;
3231.             return;
3232.         }
3234.         if (! (class_exists($className) || interface_exists($className))) {
3235.             throw MappingException::invalidClassInDiscriminatorMap($className, $this->name);
3236.         }
3238.         $this->addSubClass($className);
3239.     }
3241.     /** @param array<class-string> $classes */
3242.     public function addSubClasses(array $classes): void
3243.     {
3244.         foreach ($classes as $className) {
3245.             $this->addSubClass($className);
3246.         }
3247.     }
3249.     public function addSubClass(string $className): void
3250.     {
3251.         // By ignoring classes that are not subclasses of the current class, we simplify inheriting
3252.         // the subclass list from a parent class at the beginning of \Doctrine\ORM\Mapping\ClassMetadataFactory::doLoadMetadata.
3253.         if (is_subclass_of($className, $this->name) && ! in_array($className, $this->subClasses, true)) {
3254.             $this->subClasses[] = $className;
3255.         }
3256.     }
3258.     /**
3259.      * Checks whether the class has a named query with the given query name.
3260.      *
3261.      * @param string $queryName
3262.      *
3263.      * @return bool
3264.      */
3265.     public function hasNamedQuery($queryName)
3266.     {
3267.         return isset($this->namedQueries[$queryName]);
3268.     }
3270.     /**
3271.      * Checks whether the class has a named native query with the given query name.
3272.      *
3273.      * @param string $queryName
3274.      *
3275.      * @return bool
3276.      */
3277.     public function hasNamedNativeQuery($queryName)
3278.     {
3279.         return isset($this->namedNativeQueries[$queryName]);
3280.     }
3282.     /**
3283.      * Checks whether the class has a named native query with the given query name.
3284.      *
3285.      * @param string $name
3286.      *
3287.      * @return bool
3288.      */
3289.     public function hasSqlResultSetMapping($name)
3290.     {
3291.         return isset($this->sqlResultSetMappings[$name]);
3292.     }
3294.     /**
3295.      * {@inheritDoc}
3296.      */
3297.     public function hasAssociation($fieldName)
3298.     {
3299.         return isset($this->associationMappings[$fieldName]);
3300.     }
3302.     /**
3303.      * {@inheritDoc}
3304.      */
3305.     public function isSingleValuedAssociation($fieldName)
3306.     {
3307.         return isset($this->associationMappings[$fieldName])
3308.             && ($this->associationMappings[$fieldName]['type'] & self::TO_ONE);
3309.     }
3311.     /**
3312.      * {@inheritDoc}
3313.      */
3314.     public function isCollectionValuedAssociation($fieldName)
3315.     {
3316.         return isset($this->associationMappings[$fieldName])
3317.             && ! ($this->associationMappings[$fieldName]['type'] & self::TO_ONE);
3318.     }
3320.     /**
3321.      * Is this an association that only has a single join column?
3322.      *
3323.      * @param string $fieldName
3324.      *
3325.      * @return bool
3326.      */
3327.     public function isAssociationWithSingleJoinColumn($fieldName)
3328.     {
3329.         return isset($this->associationMappings[$fieldName])
3330.             && isset($this->associationMappings[$fieldName]['joinColumns'][0])
3331.             && ! isset($this->associationMappings[$fieldName]['joinColumns'][1]);
3332.     }
3334.     /**
3335.      * Returns the single association join column (if any).
3336.      *
3337.      * @param string $fieldName
3338.      *
3339.      * @return string
3340.      *
3341.      * @throws MappingException
3342.      */
3343.     public function getSingleAssociationJoinColumnName($fieldName)
3344.     {
3345.         if (! $this->isAssociationWithSingleJoinColumn($fieldName)) {
3346.             throw MappingException::noSingleAssociationJoinColumnFound($this->name, $fieldName);
3347.         }
3349.         return $this->associationMappings[$fieldName]['joinColumns'][0]['name'];
3350.     }
3352.     /**
3353.      * Returns the single association referenced join column name (if any).
3354.      *
3355.      * @param string $fieldName
3356.      *
3357.      * @return string
3358.      *
3359.      * @throws MappingException
3360.      */
3361.     public function getSingleAssociationReferencedJoinColumnName($fieldName)
3362.     {
3363.         if (! $this->isAssociationWithSingleJoinColumn($fieldName)) {
3364.             throw MappingException::noSingleAssociationJoinColumnFound($this->name, $fieldName);
3365.         }
3367.         return $this->associationMappings[$fieldName]['joinColumns'][0]['referencedColumnName'];
3368.     }
3370.     /**
3371.      * Used to retrieve a fieldname for either field or association from a given column.
3372.      *
3373.      * This method is used in foreign-key as primary-key contexts.
3374.      *
3375.      * @param string $columnName
3376.      *
3377.      * @return string
3378.      *
3379.      * @throws MappingException
3380.      */
3381.     public function getFieldForColumn($columnName)
3382.     {
3383.         if (isset($this->fieldNames[$columnName])) {
3384.             return $this->fieldNames[$columnName];
3385.         }
3387.         foreach ($this->associationMappings as $assocName => $mapping) {
3388.             if (
3389.                 $this->isAssociationWithSingleJoinColumn($assocName) &&
3390.                 $this->associationMappings[$assocName]['joinColumns'][0]['name'] === $columnName
3391.             ) {
3392.                 return $assocName;
3393.             }
3394.         }
3396.         throw MappingException::noFieldNameFoundForColumn($this->name, $columnName);
3397.     }
3399.     /**
3400.      * Sets the ID generator used to generate IDs for instances of this class.
3401.      *
3402.      * @param AbstractIdGenerator $generator
3403.      *
3404.      * @return void
3405.      */
3406.     public function setIdGenerator($generator)
3407.     {
3408.         $this->idGenerator = $generator;
3409.     }
3411.     /**
3412.      * Sets definition.
3413.      *
3414.      * @psalm-param array<string, string|null> $definition
3415.      *
3416.      * @return void
3417.      */
3418.     public function setCustomGeneratorDefinition(array $definition)
3419.     {
3420.         $this->customGeneratorDefinition = $definition;
3421.     }
3423.     /**
3424.      * Sets the definition of the sequence ID generator for this class.
3425.      *
3426.      * The definition must have the following structure:
3427.      * <code>
3428.      * array(
3429.      *     'sequenceName'   => 'name',
3430.      *     'allocationSize' => 20,
3431.      *     'initialValue'   => 1
3432.      *     'quoted'         => 1
3433.      * )
3434.      * </code>
3435.      *
3436.      * @psalm-param array{sequenceName?: string, allocationSize?: int|string, initialValue?: int|string, quoted?: mixed} $definition
3437.      *
3438.      * @return void
3439.      *
3440.      * @throws MappingException
3441.      */
3442.     public function setSequenceGeneratorDefinition(array $definition)
3443.     {
3444.         if (! isset($definition['sequenceName']) || trim($definition['sequenceName']) === '') {
3445.             throw MappingException::missingSequenceName($this->name);
3446.         }
3448.         if ($definition['sequenceName'][0] === '`') {
3449.             $definition['sequenceName'] = trim($definition['sequenceName'], '`');
3450.             $definition['quoted']       = true;
3451.         }
3453.         if (! isset($definition['allocationSize']) || trim((string) $definition['allocationSize']) === '') {
3454.             $definition['allocationSize'] = '1';
3455.         }
3457.         if (! isset($definition['initialValue']) || trim((string) $definition['initialValue']) === '') {
3458.             $definition['initialValue'] = '1';
3459.         }
3461.         $definition['allocationSize'] = (string) $definition['allocationSize'];
3462.         $definition['initialValue']   = (string) $definition['initialValue'];
3464.         $this->sequenceGeneratorDefinition = $definition;
3465.     }
3467.     /**
3468.      * Sets the version field mapping used for versioning. Sets the default
3469.      * value to use depending on the column type.
3470.      *
3471.      * @psalm-param array<string, mixed> $mapping The version field mapping array.
3472.      *
3473.      * @return void
3474.      *
3475.      * @throws MappingException
3476.      */
3477.     public function setVersionMapping(array &$mapping)
3478.     {
3479.         $this->isVersioned              = true;
3480.         $this->versionField             = $mapping['fieldName'];
3481.         $this->requiresFetchAfterChange = true;
3483.         if (! isset($mapping['default'])) {
3484.             if (in_array($mapping['type'], ['integer', 'bigint', 'smallint'], true)) {
3485.                 $mapping['default'] = 1;
3486.             } elseif ($mapping['type'] === 'datetime') {
3487.                 $mapping['default'] = 'CURRENT_TIMESTAMP';
3488.             } else {
3489.                 throw MappingException::unsupportedOptimisticLockingType($this->name, $mapping['fieldName'], $mapping['type']);
3490.             }
3491.         }
3492.     }
3494.     /**
3495.      * Sets whether this class is to be versioned for optimistic locking.
3496.      *
3497.      * @param bool $bool
3498.      *
3499.      * @return void
3500.      */
3501.     public function setVersioned($bool)
3502.     {
3503.         $this->isVersioned = $bool;
3505.         if ($bool) {
3506.             $this->requiresFetchAfterChange = true;
3507.         }
3508.     }
3510.     /**
3511.      * Sets the name of the field that is to be used for versioning if this class is
3512.      * versioned for optimistic locking.
3513.      *
3514.      * @param string|null $versionField
3515.      *
3516.      * @return void
3517.      */
3518.     public function setVersionField($versionField)
3519.     {
3520.         $this->versionField = $versionField;
3521.     }
3523.     /**
3524.      * Marks this class as read only, no change tracking is applied to it.
3525.      *
3526.      * @return void
3527.      */
3528.     public function markReadOnly()
3529.     {
3530.         $this->isReadOnly = true;
3531.     }
3533.     /**
3534.      * {@inheritDoc}
3535.      */
3536.     public function getFieldNames()
3537.     {
3538.         return array_keys($this->fieldMappings);
3539.     }
3541.     /**
3542.      * {@inheritDoc}
3543.      */
3544.     public function getAssociationNames()
3545.     {
3546.         return array_keys($this->associationMappings);
3547.     }
3549.     /**
3550.      * {@inheritDoc}
3551.      *
3552.      * @param string $assocName
3553.      *
3554.      * @return string
3555.      * @psalm-return class-string
3556.      *
3557.      * @throws InvalidArgumentException
3558.      */
3559.     public function getAssociationTargetClass($assocName)
3560.     {
3561.         if (! isset($this->associationMappings[$assocName])) {
3562.             throw new InvalidArgumentException("Association name expected, '" . $assocName . "' is not an association.");
3563.         }
3565.         return $this->associationMappings[$assocName]['targetEntity'];
3566.     }
3568.     /**
3569.      * {@inheritDoc}
3570.      */
3571.     public function getName()
3572.     {
3573.         return $this->name;
3574.     }
3576.     /**
3577.      * Gets the (possibly quoted) identifier column names for safe use in an SQL statement.
3578.      *
3579.      * @deprecated Deprecated since version 2.3 in favor of \Doctrine\ORM\Mapping\QuoteStrategy
3580.      *
3581.      * @param AbstractPlatform $platform
3582.      *
3583.      * @return string[]
3584.      * @psalm-return list<string>
3585.      */
3586.     public function getQuotedIdentifierColumnNames($platform)
3587.     {
3588.         $quotedColumnNames = [];
3590.         foreach ($this->identifier as $idProperty) {
3591.             if (isset($this->fieldMappings[$idProperty])) {
3592.                 $quotedColumnNames[] = isset($this->fieldMappings[$idProperty]['quoted'])
3593.                     ? $platform->quoteIdentifier($this->fieldMappings[$idProperty]['columnName'])
3594.                     : $this->fieldMappings[$idProperty]['columnName'];
3596.                 continue;
3597.             }
3599.             // Association defined as Id field
3600.             $joinColumns            = $this->associationMappings[$idProperty]['joinColumns'];
3601.             $assocQuotedColumnNames = array_map(
3602.                 static function ($joinColumn) use ($platform) {
3603.                     return isset($joinColumn['quoted'])
3604.                         ? $platform->quoteIdentifier($joinColumn['name'])
3605.                         : $joinColumn['name'];
3606.                 },
3607.                 $joinColumns
3608.             );
3610.             $quotedColumnNames = array_merge($quotedColumnNames, $assocQuotedColumnNames);
3611.         }
3613.         return $quotedColumnNames;
3614.     }
3616.     /**
3617.      * Gets the (possibly quoted) column name of a mapped field for safe use  in an SQL statement.
3618.      *
3619.      * @deprecated Deprecated since version 2.3 in favor of \Doctrine\ORM\Mapping\QuoteStrategy
3620.      *
3621.      * @param string           $field
3622.      * @param AbstractPlatform $platform
3623.      *
3624.      * @return string
3625.      */
3626.     public function getQuotedColumnName($field, $platform)
3627.     {
3628.         return isset($this->fieldMappings[$field]['quoted'])
3629.             ? $platform->quoteIdentifier($this->fieldMappings[$field]['columnName'])
3630.             : $this->fieldMappings[$field]['columnName'];
3631.     }
3633.     /**
3634.      * Gets the (possibly quoted) primary table name of this class for safe use in an SQL statement.
3635.      *
3636.      * @deprecated Deprecated since version 2.3 in favor of \Doctrine\ORM\Mapping\QuoteStrategy
3637.      *
3638.      * @param AbstractPlatform $platform
3639.      *
3640.      * @return string
3641.      */
3642.     public function getQuotedTableName($platform)
3643.     {
3644.         return isset($this->table['quoted'])
3645.             ? $platform->quoteIdentifier($this->table['name'])
3646.             : $this->table['name'];
3647.     }
3649.     /**
3650.      * Gets the (possibly quoted) name of the join table.
3651.      *
3652.      * @deprecated Deprecated since version 2.3 in favor of \Doctrine\ORM\Mapping\QuoteStrategy
3653.      *
3654.      * @param mixed[]          $assoc
3655.      * @param AbstractPlatform $platform
3656.      *
3657.      * @return string
3658.      */
3659.     public function getQuotedJoinTableName(array $assoc, $platform)
3660.     {
3661.         return isset($assoc['joinTable']['quoted'])
3662.             ? $platform->quoteIdentifier($assoc['joinTable']['name'])
3663.             : $assoc['joinTable']['name'];
3664.     }
3666.     /**
3667.      * {@inheritDoc}
3668.      */
3669.     public function isAssociationInverseSide($fieldName)
3670.     {
3671.         return isset($this->associationMappings[$fieldName])
3672.             && ! $this->associationMappings[$fieldName]['isOwningSide'];
3673.     }
3675.     /**
3676.      * {@inheritDoc}
3677.      */
3678.     public function getAssociationMappedByTargetField($fieldName)
3679.     {
3680.         return $this->associationMappings[$fieldName]['mappedBy'];
3681.     }
3683.     /**
3684.      * @param string $targetClass
3685.      *
3686.      * @return mixed[][]
3687.      * @psalm-return array<string, array<string, mixed>>
3688.      */
3689.     public function getAssociationsByTargetClass($targetClass)
3690.     {
3691.         $relations = [];
3693.         foreach ($this->associationMappings as $mapping) {
3694.             if ($mapping['targetEntity'] === $targetClass) {
3695.                 $relations[$mapping['fieldName']] = $mapping;
3696.             }
3697.         }
3699.         return $relations;
3700.     }
3702.     /**
3703.      * @param string|null $className
3704.      *
3705.      * @return string|null null if the input value is null
3706.      * @psalm-return class-string|null
3707.      */
3708.     public function fullyQualifiedClassName($className)
3709.     {
3710.         if (empty($className)) {
3711.             return $className;
3712.         }
3714.         if (! str_contains($className, '\\') && $this->namespace) {
3715.             return $this->namespace . '\\' . $className;
3716.         }
3718.         return $className;
3719.     }
3721.     /**
3722.      * @param string $name
3723.      *
3724.      * @return mixed
3725.      */
3726.     public function getMetadataValue($name)
3727.     {
3728.         if (isset($this->$name)) {
3729.             return $this->$name;
3730.         }
3732.         return null;
3733.     }
3735.     /**
3736.      * Map Embedded Class
3737.      *
3738.      * @psalm-param array<string, mixed> $mapping
3739.      *
3740.      * @return void
3741.      *
3742.      * @throws MappingException
3743.      */
3744.     public function mapEmbedded(array $mapping)
3745.     {
3746.         $this->assertFieldNotMapped($mapping['fieldName']);
3748.         if (! isset($mapping['class']) && $this->isTypedProperty($mapping['fieldName'])) {
3749.             $type = $this->reflClass->getProperty($mapping['fieldName'])->getType();
3750.             if ($type instanceof ReflectionNamedType) {
3751.                 $mapping['class'] = $type->getName();
3752.             }
3753.         }
3755.         if (! (isset($mapping['class']) && $mapping['class'])) {
3756.             throw MappingException::missingEmbeddedClass($mapping['fieldName']);
3757.         }
3759.         $fqcn = $this->fullyQualifiedClassName($mapping['class']);
3761.         assert($fqcn !== null);
3763.         $this->embeddedClasses[$mapping['fieldName']] = [
3764.             'class' => $fqcn,
3765.             'columnPrefix' => $mapping['columnPrefix'] ?? null,
3766.             'declaredField' => $mapping['declaredField'] ?? null,
3767.             'originalField' => $mapping['originalField'] ?? null,
3768.         ];
3769.     }
3771.     /**
3772.      * Inline the embeddable class
3773.      *
3774.      * @param string $property
3775.      *
3776.      * @return void
3777.      */
3778.     public function inlineEmbeddable($property, ClassMetadataInfo $embeddable)
3779.     {
3780.         foreach ($embeddable->fieldMappings as $fieldMapping) {
3781.             $fieldMapping['originalClass'] = $fieldMapping['originalClass'] ?? $embeddable->name;
3782.             $fieldMapping['declaredField'] = isset($fieldMapping['declaredField'])
3783.                 ? $property . '.' . $fieldMapping['declaredField']
3784.                 : $property;
3785.             $fieldMapping['originalField'] = $fieldMapping['originalField'] ?? $fieldMapping['fieldName'];
3786.             $fieldMapping['fieldName']     = $property . '.' . $fieldMapping['fieldName'];
3788.             if (! empty($this->embeddedClasses[$property]['columnPrefix'])) {
3789.                 $fieldMapping['columnName'] = $this->embeddedClasses[$property]['columnPrefix'] . $fieldMapping['columnName'];
3790.             } elseif ($this->embeddedClasses[$property]['columnPrefix'] !== false) {
3791.                 $fieldMapping['columnName'] = $this->namingStrategy
3792.                     ->embeddedFieldToColumnName(
3793.                         $property,
3794.                         $fieldMapping['columnName'],
3795.                         $this->reflClass->name,
3796.                         $embeddable->reflClass->name
3797.                     );
3798.             }
3800.             $this->mapField($fieldMapping);
3801.         }
3802.     }
3804.     /** @throws MappingException */
3805.     private function assertFieldNotMapped(string $fieldName): void
3806.     {
3807.         if (
3808.             isset($this->fieldMappings[$fieldName]) ||
3809.             isset($this->associationMappings[$fieldName]) ||
3810.             isset($this->embeddedClasses[$fieldName])
3811.         ) {
3812.             throw MappingException::duplicateFieldMapping($this->name, $fieldName);
3813.         }
3814.     }
3816.     /**
3817.      * Gets the sequence name based on class metadata.
3818.      *
3819.      * @return string
3820.      *
3821.      * @todo Sequence names should be computed in DBAL depending on the platform
3822.      */
3823.     public function getSequenceName(AbstractPlatform $platform)
3824.     {
3825.         $sequencePrefix = $this->getSequencePrefix($platform);
3826.         $columnName     = $this->getSingleIdentifierColumnName();
3828.         return $sequencePrefix . '_' . $columnName . '_seq';
3829.     }
3831.     /**
3832.      * Gets the sequence name prefix based on class metadata.
3833.      *
3834.      * @return string
3835.      *
3836.      * @todo Sequence names should be computed in DBAL depending on the platform
3837.      */
3838.     public function getSequencePrefix(AbstractPlatform $platform)
3839.     {
3840.         $tableName      = $this->getTableName();
3841.         $sequencePrefix = $tableName;
3843.         // Prepend the schema name to the table name if there is one
3844.         $schemaName = $this->getSchemaName();
3845.         if ($schemaName) {
3846.             $sequencePrefix = $schemaName . '.' . $tableName;
3848.             if (! $platform->supportsSchemas() && $platform->canEmulateSchemas()) {
3849.                 $sequencePrefix = $schemaName . '__' . $tableName;
3850.             }
3851.         }
3853.         return $sequencePrefix;
3854.     }
3856.     /** @psalm-param AssociationMapping $mapping */
3857.     private function assertMappingOrderBy(array $mapping): void
3858.     {
3859.         if (isset($mapping['orderBy']) && ! is_array($mapping['orderBy'])) {
3860.             throw new InvalidArgumentException("'orderBy' is expected to be an array, not " . gettype($mapping['orderBy']));
3861.         }
3862.     }
3864.     /** @psalm-param class-string $class */
3865.     private function getAccessibleProperty(ReflectionService $reflService, string $class, string $field): ?ReflectionProperty
3866.     {
3867.         $reflectionProperty = $reflService->getAccessibleProperty($class, $field);
3868.         if ($reflectionProperty !== null && PHP_VERSION_ID >= 80100 && $reflectionProperty->isReadOnly()) {
3869.             $declaringClass = $reflectionProperty->class;
3870.             if ($declaringClass !== $class) {
3871.                 $reflectionProperty = $reflService->getAccessibleProperty($declaringClass, $field);
3872.             }
3874.             if ($reflectionProperty !== null) {
3875.                 $reflectionProperty = new ReflectionReadonlyProperty($reflectionProperty);
3876.             }
3877.         }
3879.         return $reflectionProperty;
3880.     }
3881. }