vendor\doctrine\orm\lib\Doctrine\ORM\Mapping\ClassMetadataInfo.php line 1206

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