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

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