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

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