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

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