199 lines
5.6 KiB
Plaintext
199 lines
5.6 KiB
Plaintext
Doctrine 2 also allows you to provide the ORM metadata in the form of plain
|
|
PHP code using the `ClassMetadata` API. You can write the code in PHP files or
|
|
inside of a static function named `loadMetadata($class)` on the entity class itself.
|
|
|
|
++ PHP Files
|
|
|
|
If you wish to write your mapping information inside PHP files that are named
|
|
after the entity and included to populate the metadata for an entity you can do
|
|
so by using the `PHPDriver`:
|
|
|
|
[php]
|
|
$driver = new PHPDriver('/path/to/php/mapping/files');
|
|
$em->getConfiguration()->setMetadataDriverImpl($driver);
|
|
|
|
Now imagine we had an entity named `Entities\User` and we wanted to write a mapping
|
|
file for it using the above configured `PHPDriver` instance:
|
|
|
|
[php]
|
|
namespace Entities;
|
|
|
|
class User
|
|
{
|
|
private $id;
|
|
private $username;
|
|
}
|
|
|
|
To write the mapping information you just need to create a file named
|
|
`Entities.User.php` inside of the `/path/to/php/mapping/files` folder:
|
|
|
|
[php]
|
|
// /path/to/php/mapping/files/Entities.User.php
|
|
|
|
$metadata->mapField(array(
|
|
'id' => true,
|
|
'fieldName' => 'id',
|
|
'type' => 'integer'
|
|
));
|
|
|
|
$metadata->mapField(array(
|
|
'fieldName' => 'username',
|
|
'type' => 'string'
|
|
));
|
|
|
|
Now we can easily retrieve the populated `ClassMetadata` instance where the `PHPDriver`
|
|
includes the file and the `ClassMetadataFactory` caches it for later retrieval:
|
|
|
|
[php]
|
|
$class = $em->getMetadataFor('Entities\User');
|
|
|
|
++ Static Function
|
|
|
|
In addition to the PHP files you can also specify your mapping information inside
|
|
of a static function defined on the entity class itself. This is useful for cases
|
|
where you want to keep your entity and mapping information together but don't want
|
|
to use annotations. For this you just need to use the `StaticPHPDriver`:
|
|
|
|
[php]
|
|
$driver = new StaticPHPDriver('/path/to/entities');
|
|
$em->getConfiguration()->setMetadataDriverImpl($driver);
|
|
|
|
Now you just need to define a static function named `loadMetadata($metadata)` on your entity:
|
|
|
|
[php]
|
|
namespace Entities;
|
|
|
|
use Doctrine\ORM\Mapping\ClassMetadata;
|
|
|
|
class User
|
|
{
|
|
// ...
|
|
|
|
public static function loadMetadata(ClassMetadata $metadata)
|
|
{
|
|
$metadata->mapField(array(
|
|
'id' => true,
|
|
'fieldName' => 'id',
|
|
'type' => 'integer'
|
|
));
|
|
|
|
$metadata->mapField(array(
|
|
'fieldName' => 'username',
|
|
'type' => 'string'
|
|
));
|
|
}
|
|
}
|
|
|
|
++ ClassMetadataInfo API
|
|
|
|
The `ClassMetadataInfo` class is the base data object for storing the mapping
|
|
metadata for a single entity. It contains all the getters and setters you need
|
|
populate and retrieve information for an entity.
|
|
|
|
+++ General Setters
|
|
|
|
* `setTableName($tableName)`
|
|
* `setPrimaryTable(array $primaryTableDefinition)`
|
|
* `setCustomRepositoryClass($repositoryClassName)`
|
|
* `setIdGeneratorType($generatorType)`
|
|
* `setIdGenerator($generator)`
|
|
* `setSequenceGeneratorDefinition(array $definition)`
|
|
* `setChangeTrackingPolicy($policy)`
|
|
* `setIdentifier(array $identifier)`
|
|
|
|
+++ Inheritance Setters
|
|
|
|
* `setInheritanceType($type)`
|
|
* `setSubclasses(array $subclasses)`
|
|
* `setParentClasses(array $classNames)`
|
|
* `setDiscriminatorColumn($columnDef)`
|
|
* `setDiscriminatorMap(array $map)`
|
|
|
|
+++ Field Mapping Setters
|
|
|
|
* `mapField(array $mapping)`
|
|
* `mapOneToOne(array $mapping)`
|
|
* `mapOneToMany(array $mapping)`
|
|
* `mapManyToOne(array $mapping)`
|
|
* `mapManyToMany(array $mapping)`
|
|
|
|
+++ Lifecycle Callback Setters
|
|
|
|
* `addLifecycleCallback($callback, $event)`
|
|
* `setLifecycleCallbacks(array $callbacks)`
|
|
|
|
+++ Versioning Setters
|
|
|
|
* `setVersionMapping(array &$mapping)`
|
|
* `setVersioned($bool)`
|
|
* `setVersionField()`
|
|
|
|
+++ General Getters
|
|
|
|
* `getTableName()`
|
|
* `getTemporaryIdTableName()`
|
|
|
|
+++ Identifier Getters
|
|
|
|
* `getIdentifierColumnNames()`
|
|
* `usesIdGenerator()`
|
|
* `isIdentifier($fieldName)`
|
|
* `isIdGeneratorIdentity()`
|
|
* `isIdGeneratorSequence()`
|
|
* `isIdGeneratorTable()`
|
|
* `isIdentifierNatural()`
|
|
* `getIdentifierFieldNames()`
|
|
* `getSingleIdentifierFieldName()`
|
|
* `getSingleIdentifierColumnName()`
|
|
|
|
+++ Inheritance Getters
|
|
|
|
* `isInheritanceTypeNone()`
|
|
* `isInheritanceTypeJoined()`
|
|
* `isInheritanceTypeSingleTable()`
|
|
* `isInheritanceTypeTablePerClass()`
|
|
* `isInheritedField($fieldName)`
|
|
* `isInheritedAssociation($fieldName)`
|
|
|
|
+++ Change Tracking Getters
|
|
|
|
* `isChangeTrackingDeferredExplicit()`
|
|
* `isChangeTrackingDeferredImplicit()`
|
|
* `isChangeTrackingNotify()`
|
|
|
|
+++ Field & Association Getters
|
|
|
|
* `isUniqueField($fieldName)`
|
|
* `isNullable($fieldName)`
|
|
* `getColumnName($fieldName)`
|
|
* `getFieldMapping($fieldName)`
|
|
* `getAssociationMapping($fieldName)`
|
|
* `getAssociationMappings()`
|
|
* `getFieldName($columnName)`
|
|
* `hasField($fieldName)`
|
|
* `getColumnNames(array $fieldNames = null)`
|
|
* `getTypeOfField($fieldName)`
|
|
* `getTypeOfColumn($columnName)`
|
|
* `hasAssociation($fieldName)`
|
|
* `isSingleValuedAssociation($fieldName)`
|
|
* `isCollectionValuedAssociation($fieldName)`
|
|
|
|
+++ Lifecycle Callback Getters
|
|
|
|
* `hasLifecycleCallbacks($lifecycleEvent)`
|
|
* `getLifecycleCallbacks($event)`
|
|
|
|
++ ClassMetadata API
|
|
|
|
The `ClassMetadata` class extends `ClassMetadataInfo` and adds the runtime functionality
|
|
required by Doctrine. It adds a few extra methods related to runtime reflection
|
|
for working with the entities themselves.
|
|
|
|
* `getReflectionClass()`
|
|
* `getReflectionProperties()`
|
|
* `getReflectionProperty($name)`
|
|
* `getSingleIdReflectionProperty()`
|
|
* `getIdentifierValues($entity)`
|
|
* `setIdentifierValues($entity, $id)`
|
|
* `setFieldValue($entity, $field, $value)`
|
|
* `getFieldValue($entity, $field)` |