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

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