Class Doctrine\ORM\Mapping\ClassMetadataInfo

Initializes a new ClassMetadata instance that will hold the object-relational mapping metadata of the class with the given name.

Gets the ReflectionProperties of the mapped class.

Gets a ReflectionProperty for a specific field of the mapped class.

Gets the ReflectionProperty for the single identifier field.

Extracts the identifier values of an entity of this class.

For composite identifiers, the identifier values are returned as an array with the same order as the field order in {@link identifier}.

Populates the entity identifier of an entity.

Sets the specified field to the specified value on the given entity.

Gets the specified field's value off the given entity.

Creates a string representation of this instance.

Determines which fields get serialized.

It is only serialized what is necessary for best unserialization performance. That means any metadata properties that are not set or empty or simply have their default value are NOT serialized.

Parts that are also NOT serialized because they can not be properly unserialized: - reflClass (ReflectionClass) - reflFields (ReflectionProperty array)

Creates a new instance of the mapped class, without invoking the constructor.

Restores some state that can not be serialized/unserialized.

Initializes a new ClassMetadata instance that will hold the object-relational mapping metadata of the class with the given name.

Validates Identifier.

Validates association targets actually exist.

Validates lifecycle callbacks.

{@inheritDoc}

Sets the change tracking policy used by this class.

Whether the change tracking policy of this class is "deferred explicit".

Whether the change tracking policy of this class is "deferred implicit".

Whether the change tracking policy of this class is "notify".

Checks whether a field is part of the identifier/primary key field(s).

Checks if the field is unique.

Checks if the field is not null.

Gets a column name for a field name. If the column name for the field cannot be found, the given field name is returned.

Gets the mapping of a (regular) field that holds some data but not a reference to another object.

Gets the mapping of an association.

Gets all association mappings of the class.

Gets the field name for a column name. If no field name can be found the column name is returned.

Gets the named query.

Gets all named queries of the class.

Gets the named native query.

Gets all named native queries of the class.

Gets the result set mapping.

Gets all sql result set mappings of the class.

Checks whether given property has type

Validates & completes the given field mapping based on typed property.

Validates & completes the basic mapping information based on typed property.

Validates & completes the given field mapping.

Validates & completes the basic mapping information that is common to all association mappings (one-to-one, many-ot-one, one-to-many, many-to-many).

Validates & completes a one-to-one association mapping.

Validates & completes a one-to-many association mapping.

Validates & completes a many-to-many association mapping.

{@inheritDoc}

Gets the name of the single id field. Note that this only works on entity classes that have a single-field pk.

Gets the column name of the single id column. Note that this only works on entity classes that have a single-field pk.

INTERNAL: Sets the mapped identifier/primary key fields of this class. Mainly used by the ClassMetadataFactory to assign inherited identifiers.

{@inheritDoc}

{@inheritDoc}

Gets an array containing all the column names.

Returns an array with all the identifier column names.

Sets the type of Id generator to use for the mapped class.

Checks whether the mapped class uses an Id generator.

Checks whether the mapped class uses the JOINED inheritance mapping strategy.

Checks whether the mapped class uses the SINGLE_TABLE inheritance mapping strategy.

Checks whether the mapped class uses the TABLE_PER_CLASS inheritance mapping strategy.

Checks whether the class uses an identity column for the Id generation.

Checks whether the class uses a sequence for id generation.

Checks whether the class uses a table for id generation.

Checks whether the class has a natural identifier/pk (which means it does not use any Id generator.

Checks whether the class use a UUID for id generation.

Gets the type of a field.

Gets the type of a column.

Gets the name of the primary table.

Gets primary table's schema name.

Gets the table name to use for temporary identifier tables of this class.

Sets the mapped subclasses of this class.

Sets the parent class names. Only entity classes may be given.

Assumes that the class names in the passed array are in the order: directParent -> directParentParent -> directParentParentParent ... -> root.

Sets the inheritance type used by the class and its subclasses.

Sets the association to override association mapping of property for an entity relationship.

Sets the override for a mapped field.

Checks whether a mapped field is inherited from an entity superclass.

Checks if this entity is the root in any entity-inheritance-hierarchy.

Checks whether a mapped association field is inherited from a superclass.

Sets the name of the primary table the class is mapped to.

Sets the primary table definition. The provided array supports the following structure:

name => <tableName> (optional, defaults to class name) indexes => array of indexes (optional) uniqueConstraints => array of constraints (optional)

If a key is omitted, the current value is kept.

Checks whether the given type identifies an inheritance type.

Adds a mapped field to the class.

INTERNAL: Adds an association mapping without completing/validating it. This is mainly used to add inherited association mappings to derived classes.

INTERNAL: Adds a field mapping without completing/validating it. This is mainly used to add inherited field mappings to derived classes.

INTERNAL: Adds a named query to this class.

INTERNAL: Adds a named native query to this class.

INTERNAL: Adds a sql result set mapping to this class.

Adds a one-to-one mapping.

Adds a one-to-many mapping.

Adds a many-to-one mapping.

Adds a many-to-many mapping.

Stores the association mapping.

Registers a custom repository class for the entity class.

Dispatches the lifecycle event of the given entity to the registered lifecycle callbacks and lifecycle listeners.

Whether the class has any attached lifecycle listeners or callbacks for a lifecycle event.

Gets the registered lifecycle callbacks for an event.

Adds a lifecycle callback for entities of this class.

Sets the lifecycle callbacks for entities of this class. Any previously registered callbacks are overwritten.

Adds a entity listener for entities of this class.

Sets the discriminator column definition.

Sets the discriminator values used by this class. Used for JOINED and SINGLE_TABLE inheritance mapping strategies.

Adds one entry of the discriminator map with a new class and corresponding name.

Checks whether the class has a named query with the given query name.

Checks whether the class has a named native query with the given query name.

Checks whether the class has a named native query with the given query name.

{@inheritDoc}

{@inheritDoc}

{@inheritDoc}

Is this an association that only has a single join column?

Returns the single association join column (if any).

Returns the single association referenced join column name (if any).

Used to retrieve a fieldname for either field or association from a given column.

This method is used in foreign-key as primary-key contexts.

Sets the ID generator used to generate IDs for instances of this class.

Sets definition.

Sets the definition of the sequence ID generator for this class.

The definition must have the following structure: array( 'sequenceName' => 'name', 'allocationSize' => 20, 'initialValue' => 1 'quoted' => 1 )

Sets the version field mapping used for versioning. Sets the default value to use depending on the column type.

Sets whether this class is to be versioned for optimistic locking.

Sets the name of the field that is to be used for versioning if this class is versioned for optimistic locking.

Marks this class as read only, no change tracking is applied to it.

{@inheritDoc}

{@inheritDoc}

{@inheritDoc}

{@inheritDoc}

Gets the (possibly quoted) identifier column names for safe use in an SQL statement.

Gets the (possibly quoted) column name of a mapped field for safe use in an SQL statement.

Gets the (possibly quoted) primary table name of this class for safe use in an SQL statement.

Gets the (possibly quoted) name of the join table.

{@inheritDoc}

{@inheritDoc}

Map Embedded Class

Inline the embeddable class

Gets the sequence name based on class metadata.

Gets the sequence name prefix based on class metadata.

NONE means the class does not participate in an inheritance hierarchy and therefore does not need an inheritance mapping type.

JOINED means the class will be persisted according to the rules of Class Table Inheritance.

SINGLE_TABLE means the class will be persisted according to the rules of Single Table Inheritance.

TABLE_PER_CLASS means the class will be persisted according to the rules of Concrete Table Inheritance.

AUTO means the generator type will depend on what the used platform prefers. Offers full portability.

SEQUENCE means a separate sequence object will be used. Platforms that do not have native sequence support may emulate it. Full portability is currently not guaranteed.

TABLE means a separate table is used for id generation. Offers full portability (in that it results in an exception being thrown no matter the platform).

IDENTITY means an identity column is used for id generation. The database will fill in the id column on insertion. Platforms that do not support native identity columns may emulate them. Full portability is currently not guaranteed.

NONE means the class does not have a generated id. That means the class must have a natural, manually assigned id.

UUID means that a UUID/GUID expression is used for id generation. Full portability is currently not guaranteed.

CUSTOM means that customer will use own ID generator that supposedly work

DEFERRED_IMPLICIT means that changes of entities are calculated at commit-time by doing a property-by-property comparison with the original data. This will be done for all entities that are in MANAGED state at commit-time.

This is the default change tracking policy.

DEFERRED_EXPLICIT means that changes of entities are calculated at commit-time by doing a property-by-property comparison with the original data. This will be done only for entities that were explicitly saved (through persist() or a cascade).

NOTIFY means that Doctrine relies on the entities sending out notifications when their properties change. Such entity classes must implement the NotifyPropertyChanged interface.

Specifies that an association is to be fetched when it is first accessed.

Specifies that an association is to be fetched when the owner of the association is fetched.

Specifies that an association is to be fetched lazy (on first access) and that commands such as Collection#count, Collection#slice are issued directly against the database if the collection is not yet initialized.

Identifies a one-to-one association.

Identifies a many-to-one association.

Identifies a one-to-many association.

Identifies a many-to-many association.

Combined bitmask for to-one (single-valued) associations.

Combined bitmask for to-many (collection-valued) associations.

ReadOnly cache can do reads, inserts and deletes, cannot perform updates or employ any locks,

Nonstrict Read Write Cache doesn’t employ any locks but can do inserts, update and deletes.

Read Write Attempts to lock the entity before update/delete.

The value of this column is never generated by the database.

The value of this column is generated by the database on INSERT, but not on UPDATE.

The value of this column is generated by the database on both INSERT and UDPATE statements.

READ-ONLY: The names of the parent entity classes (ancestors), starting with the nearest one and ending with the root entity class.

READ-ONLY: For classes in inheritance mapping hierarchies, this field contains the names of all entity subclasses of this class. These may also be abstract classes.

This list is used, for example, to enumerate all necessary tables in JTI when querying for root or subclass entities, or to gather all fields comprised in an entity inheritance tree.

For classes that do not use STI/JTI, this list is empty.

Implementation note:

In PHP, there is no general way to discover all subclasses of a given class at runtime. For that reason, the list of classes given in the discriminator map at the root entity is considered authoritative. The discriminator map must contain all concrete classes that can appear in the particular inheritance hierarchy tree. Since there can be no instances of abstract entity classes, users are not required to list such classes with a discriminator value.

The possibly remaining "gaps" for abstract entity classes are filled after the class metadata for the root entity has been loaded.

For subclasses of such root entities, the list can be reused/passed downwards, it only needs to be filtered accordingly (only keep remaining subclasses)

READ-ONLY: The names of all embedded classes based on properties.

The value (definition) array may contain, among others, the following values:

• 'inherited' (string, optional) This is set when this embedded-class field is inherited by this class from another (inheritance) parent entity class. The value is the FQCN of the topmost entity class that contains mapping information for this field. (If there are transient classes in the class hierarchy, these are ignored, so the class property may in fact come from a class further up in the PHP class hierarchy.) Fields initially declared in mapped superclasses are not considered 'inherited' in the nearest entity subclasses.

• 'declared' (string, optional) This is set when the embedded-class field does not appear for the first time in this class, but is originally declared in another parent entity or mapped superclass. The value is the FQCN of the topmost non-transient class that contains mapping information for this field.

READ-ONLY: The named queries allowed to be called directly from Repository.

READ-ONLY: The named native queries allowed to be called directly from Repository.

A native SQL named query definition has the following structure:

array(
    'name'               => ,
    'query'              => ,
    'resultClass'        => ,
    'resultSetMapping'   => 
)

READ-ONLY: The mappings of the results of native SQL queries.

A native result mapping definition has the following structure:

array(
    'name'               => ,
    'entities'           => array(),
    'columns'            => array()
)

READ-ONLY: The field names of all fields that are part of the identifier/primary key of the mapped entity class.

READ-ONLY: An array of field names. Used to look up field names from column names. Keys are column names and values are field names.

READ-ONLY: The registered lifecycle callbacks for entities of this class.

READ-ONLY: The registered entity listeners.

READ-ONLY: The association mappings of this class.

The mapping definition array supports the following keys:

• fieldName (string) The name of the field in the entity the association is mapped to.

• sourceEntity (string) The class name of the source entity. In the case of to-many associations initially present in mapped superclasses, the nearest entity subclasses will be considered the respective source entities.

• targetEntity (string) The class name of the target entity. If it is fully-qualified it is used as is. If it is a simple, unqualified class name the namespace is assumed to be the same as the namespace of the source entity.

• mappedBy (string, required for bidirectional associations) The name of the field that completes the bidirectional association on the owning side. This key must be specified on the inverse side of a bidirectional association.

• inversedBy (string, required for bidirectional associations) The name of the field that completes the bidirectional association on the inverse side. This key must be specified on the owning side of a bidirectional association.

• cascade (array, optional) The names of persistence operations to cascade on the association. The set of possible values are: "persist", "remove", "detach", "merge", "refresh", "all" (implies all others).

• orderBy (array, one-to-many/many-to-many only) A map of field names (of the target entity) to sorting directions (ASC/DESC). Example: array('priority' => 'desc')

• fetch (integer, optional) The fetching strategy to use for the association, usually defaults to FETCH_LAZY. Possible values are: ClassMetadata::FETCH_EAGER, ClassMetadata::FETCH_LAZY.

• joinTable (array, optional, many-to-many only) Specification of the join table and its join columns (foreign keys). Only valid for many-to-many mappings. Note that one-to-many associations can be mapped through a join table by simply mapping the association as many-to-many with a unique constraint on the join table.

• indexBy (string, optional, to-many only) Specification of a field on target-entity that is used to index the collection by. This field HAS to be either the primary key or a unique column. Otherwise the collection does not contain all the entities that are actually related.

• 'inherited' (string, optional) This is set when the association is inherited by this class from another (inheritance) parent entity class. The value is the FQCN of the topmost entity class that contains this association. (If there are transient classes in the class hierarchy, these are ignored, so the class property may in fact come from a class further up in the PHP class hierarchy.) To-many associations initially declared in mapped superclasses are not considered 'inherited' in the nearest entity subclasses.

• 'declared' (string, optional) This is set when the association does not appear in the current class for the first time, but is initially declared in another parent entity or mapped superclass. The value is the FQCN of the topmost non-transient class that contains association information for this relationship.

A join table definition has the following structure:

array(
    'name' => ,
     'joinColumns' => array(),
     'inverseJoinColumns' => array()
)