123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747 |
- XML Mapping
- ===========
- The XML mapping driver enables you to provide the ORM metadata in
- form of XML documents.
- The XML driver is backed by an XML Schema document that describes
- the structure of a mapping document. The most recent version of the
- XML Schema document is available online at
- `http://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd <http://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd>`_.
- In order to point to the latest version of the document of a
- particular stable release branch, just append the release number,
- i.e.: doctrine-mapping-2.0.xsd The most convenient way to work with
- XML mapping files is to use an IDE/editor that can provide
- code-completion based on such an XML Schema document. The following
- is an outline of a XML mapping document with the proper xmlns/xsi
- setup for the latest code in trunk.
- .. code-block:: xml
- <doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping
- https://raw.github.com/doctrine/doctrine2/master/doctrine-mapping.xsd">
-
- ...
-
- </doctrine-mapping>
- The XML mapping document of a class is loaded on-demand the first
- time it is requested and subsequently stored in the metadata cache.
- In order to work, this requires certain conventions:
- - Each entity/mapped superclass must get its own dedicated XML
- mapping document.
- - The name of the mapping document must consist of the fully
- qualified name of the class, where namespace separators are
- replaced by dots (.). For example an Entity with the fully
- qualified class-name "MyProject" would require a mapping file
- "MyProject.Entities.User.dcm.xml" unless the extension is changed.
- - All mapping documents should get the extension ".dcm.xml" to
- identify it as a Doctrine mapping file. This is more of a
- convention and you are not forced to do this. You can change the
- file extension easily enough.
- -
- .. code-block:: php
- <?php
- $driver->setFileExtension('.xml');
- It is recommended to put all XML mapping documents in a single
- folder but you can spread the documents over several folders if you
- want to. In order to tell the XmlDriver where to look for your
- mapping documents, supply an array of paths as the first argument
- of the constructor, like this:
- .. code-block:: php
- <?php
- $config = new \Doctrine\ORM\Configuration();
- $driver = new \Doctrine\ORM\Mapping\Driver\XmlDriver(array('/path/to/files1', '/path/to/files2'));
- $config->setMetadataDriverImpl($driver);
- Simplified XML Driver
- ~~~~~~~~~~~~~~~~~~~~~
- The Symfony project sponsored a driver that simplifies usage of the XML Driver.
- The changes between the original driver are:
- 1. File Extension is .orm.xml
- 2. Filenames are shortened, "MyProject\Entities\User" will become User.orm.xml
- 3. You can add a global file and add multiple entities in this file.
- Configuration of this client works a little bit different:
- .. code-block:: php
- <?php
- $namespaces = array(
- 'MyProject\Entities' => '/path/to/files1',
- 'OtherProject\Entities' => '/path/to/files2'
- );
- $driver = new \Doctrine\ORM\Mapping\Driver\SimplifiedXmlDriver($namespaces);
- $driver->setGlobalBasename('global'); // global.orm.xml
- Example
- -------
- As a quick start, here is a small example document that makes use
- of several common elements:
- .. code-block:: xml
- // Doctrine.Tests.ORM.Mapping.User.dcm.xml
- <?xml version="1.0" encoding="UTF-8"?>
- <doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping
- http://raw.github.com/doctrine/doctrine2/master/doctrine-mapping.xsd">
-
- <entity name="Doctrine\Tests\ORM\Mapping\User" table="cms_users">
-
- <indexes>
- <index name="name_idx" columns="name"/>
- <index columns="user_email"/>
- </indexes>
-
- <unique-constraints>
- <unique-constraint columns="name,user_email" name="search_idx" />
- </unique-constraints>
-
- <lifecycle-callbacks>
- <lifecycle-callback type="prePersist" method="doStuffOnPrePersist"/>
- <lifecycle-callback type="prePersist" method="doOtherStuffOnPrePersistToo"/>
- <lifecycle-callback type="postPersist" method="doStuffOnPostPersist"/>
- </lifecycle-callbacks>
-
- <id name="id" type="integer" column="id">
- <generator strategy="AUTO"/>
- <sequence-generator sequence-name="tablename_seq" allocation-size="100" initial-value="1" />
- </id>
-
- <field name="name" column="name" type="string" length="50" nullable="true" unique="true" />
- <field name="email" column="user_email" type="string" column-definition="CHAR(32) NOT NULL" />
-
- <one-to-one field="address" target-entity="Address" inversed-by="user">
- <cascade><cascade-remove /></cascade>
- <join-column name="address_id" referenced-column-name="id" on-delete="CASCADE" on-update="CASCADE"/>
- </one-to-one>
-
- <one-to-many field="phonenumbers" target-entity="Phonenumber" mapped-by="user">
- <cascade>
- <cascade-persist/>
- </cascade>
- <order-by>
- <order-by-field name="number" direction="ASC" />
- </order-by>
- </one-to-many>
-
- <many-to-many field="groups" target-entity="Group">
- <cascade>
- <cascade-all/>
- </cascade>
- <join-table name="cms_users_groups">
- <join-columns>
- <join-column name="user_id" referenced-column-name="id" nullable="false" unique="false" />
- </join-columns>
- <inverse-join-columns>
- <join-column name="group_id" referenced-column-name="id" column-definition="INT NULL" />
- </inverse-join-columns>
- </join-table>
- </many-to-many>
-
- </entity>
-
- </doctrine-mapping>
- Be aware that class-names specified in the XML files should be
- fully qualified.
- XML-Element Reference
- ---------------------
- The XML-Element reference explains all the tags and attributes that
- the Doctrine Mapping XSD Schema defines. You should read the
- Basic-, Association- and Inheritance Mapping chapters to understand
- what each of this definitions means in detail.
- Defining an Entity
- ~~~~~~~~~~~~~~~~~~
- Each XML Mapping File contains the definition of one entity,
- specified as the ``<entity />`` element as a direct child of the
- ``<doctrine-mapping />`` element:
- .. code-block:: xml
- <doctrine-mapping>
- <entity name="MyProject\User" table="cms_users" repository-class="MyProject\UserRepository">
- <!-- definition here -->
- </entity>
- </doctrine-mapping>
- Required attributes:
- - name - The fully qualified class-name of the entity.
- Optional attributes:
- - **table** - The Table-Name to be used for this entity. Otherwise the
- Unqualified Class-Name is used by default.
- - **repository-class** - The fully qualified class-name of an
- alternative ``Doctrine\ORM\EntityRepository`` implementation to be
- used with this entity.
- - **inheritance-type** - The type of inheritance, defaults to none. A
- more detailed description follows in the
- *Defining Inheritance Mappings* section.
- - **read-only** - (>= 2.1) Specifies that this entity is marked as read only and not
- considered for change-tracking. Entities of this type can be persisted
- and removed though.
- Defining Fields
- ~~~~~~~~~~~~~~~
- Each entity class can contain zero to infinite fields that are
- managed by Doctrine. You can define them using the ``<field />``
- element as a children to the ``<entity />`` element. The field
- element is only used for primitive types that are not the ID of the
- entity. For the ID mapping you have to use the ``<id />`` element.
- .. code-block:: xml
- <entity name="MyProject\User">
-
- <field name="name" type="string" length="50" />
- <field name="username" type="string" unique="true" />
- <field name="age" type="integer" nullable="true" />
- <field name="isActive" column="is_active" type="boolean" />
- <field name="weight" type="decimal" scale="5" precision="2" />
- </entity>
- Required attributes:
- - name - The name of the Property/Field on the given Entity PHP
- class.
- Optional attributes:
- - type - The ``Doctrine\DBAL\Types\Type`` name, defaults to
- "string"
- - column - Name of the column in the database, defaults to the
- field name.
- - length - The length of the given type, for use with strings
- only.
- - unique - Should this field contain a unique value across the
- table? Defaults to false.
- - nullable - Should this field allow NULL as a value? Defaults to
- false.
- - version - Should this field be used for optimistic locking? Only
- works on fields with type integer or datetime.
- - scale - Scale of a decimal type.
- - precision - Precision of a decimal type.
- - column-definition - Optional alternative SQL representation for
- this column. This definition begin after the field-name and has to
- specify the complete column definition. Using this feature will
- turn this field dirty for Schema-Tool update commands at all
- times.
- Defining Identity and Generator Strategies
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- An entity has to have at least one ``<id />`` element. For
- composite keys you can specify more than one id-element, however
- surrogate keys are recommended for use with Doctrine 2. The Id
- field allows to define properties of the identifier and allows a
- subset of the ``<field />`` element attributes:
- .. code-block:: xml
- <entity name="MyProject\User">
- <id name="id" type="integer" column="user_id" />
- </entity>
- Required attributes:
- - name - The name of the Property/Field on the given Entity PHP
- class.
- - type - The ``Doctrine\DBAL\Types\Type`` name, preferably
- "string" or "integer".
- Optional attributes:
- - column - Name of the column in the database, defaults to the
- field name.
- Using the simplified definition above Doctrine will use no
- identifier strategy for this entity. That means you have to
- manually set the identifier before calling
- ``EntityManager#persist($entity)``. This is the so called
- ``ASSIGNED`` strategy.
- If you want to switch the identifier generation strategy you have
- to nest a ``<generator />`` element inside the id-element. This of
- course only works for surrogate keys. For composite keys you always
- have to use the ``ASSIGNED`` strategy.
- .. code-block:: xml
- <entity name="MyProject\User">
- <id name="id" type="integer" column="user_id">
- <generator strategy="AUTO" />
- </id>
- </entity>
- The following values are allowed for the ``<generator />`` strategy
- attribute:
- - AUTO - Automatic detection of the identifier strategy based on
- the preferred solution of the database vendor.
- - IDENTITY - Use of a IDENTIFY strategy such as Auto-Increment IDs
- available to Doctrine AFTER the INSERT statement has been executed.
- - SEQUENCE - Use of a database sequence to retrieve the
- entity-ids. This is possible before the INSERT statement is
- executed.
- If you are using the SEQUENCE strategy you can define an additional
- element to describe the sequence:
- .. code-block:: xml
- <entity name="MyProject\User">
- <id name="id" type="integer" column="user_id">
- <generator strategy="SEQUENCE" />
- <sequence-generator sequence-name="user_seq" allocation-size="5" initial-value="1" />
- </id>
- </entity>
- Required attributes for ``<sequence-generator />``:
- - sequence-name - The name of the sequence
- Optional attributes for ``<sequence-generator />``:
- - allocation-size - By how much steps should the sequence be
- incremented when a value is retrieved. Defaults to 1
- - initial-value - What should the initial value of the sequence
- be.
- **NOTE**
- If you want to implement a cross-vendor compatible application you
- have to specify and additionally define the <sequence-generator />
- element, if Doctrine chooses the sequence strategy for a
- platform.
- Defining a Mapped Superclass
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Sometimes you want to define a class that multiple entities inherit
- from, which itself is not an entity however. The chapter on
- *Inheritance Mapping* describes a Mapped Superclass in detail. You
- can define it in XML using the ``<mapped-superclass />`` tag.
- .. code-block:: xml
- <doctrine-mapping>
- <mapped-superclass name="MyProject\BaseClass">
- <field name="created" type="datetime" />
- <field name="updated" type="datetime" />
- </mapped-superclass>
- </doctrine-mapping>
- Required attributes:
- - name - Class name of the mapped superclass.
- You can nest any number of ``<field />`` and unidirectional
- ``<many-to-one />`` or ``<one-to-one />`` associations inside a
- mapped superclass.
- Defining Inheritance Mappings
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- There are currently two inheritance persistence strategies that you
- can choose from when defining entities that inherit from each
- other. Single Table inheritance saves the fields of the complete
- inheritance hierarchy in a single table, joined table inheritance
- creates a table for each entity combining the fields using join
- conditions.
- You can specify the inheritance type in the ``<entity />`` element
- and then use the ``<discriminator-column />`` and
- ``<discriminator-mapping />`` attributes.
- .. code-block:: xml
- <entity name="MyProject\Animal" inheritance-type="JOINED">
- <discriminator-column name="discr" type="string" />
- <discriminator-map>
- <discriminator-mapping value="cat" class="MyProject\Cat" />
- <discriminator-mapping value="dog" class="MyProject\Dog" />
- <discriminator-mapping value="mouse" class="MyProject\Mouse" />
- </discriminator-map>
- </entity>
- The allowed values for inheritance-type attribute are ``JOINED`` or
- ``SINGLE_TABLE``.
- .. note::
- All inheritance related definitions have to be defined on the root
- entity of the hierarchy.
- Defining Lifecycle Callbacks
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- You can define the lifecycle callback methods on your entities
- using the ``<lifecycle-callbacks />`` element:
- .. code-block:: xml
- <entity name="Doctrine\Tests\ORM\Mapping\User" table="cms_users">
-
- <lifecycle-callbacks>
- <lifecycle-callback type="prePersist" method="onPrePersist" />
- </lifecycle-callbacks>
- </entity>
- Defining One-To-One Relations
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- You can define One-To-One Relations/Associations using the
- ``<one-to-one />`` element. The required and optional attributes
- depend on the associations being on the inverse or owning side.
- For the inverse side the mapping is as simple as:
- .. code-block:: xml
- <entity class="MyProject\User">
- <one-to-one field="address" target-entity="Address" mapped-by="user" />
- </entity>
- Required attributes for inverse One-To-One:
- - field - Name of the property/field on the entity's PHP class.
- - target-entity - Name of the entity associated entity class. If
- this is not qualified the namespace of the current class is
- prepended. *IMPORTANT:* No leading backslash!
- - mapped-by - Name of the field on the owning side (here Address
- entity) that contains the owning side association.
- For the owning side this mapping would look like:
- .. code-block:: xml
- <entity class="MyProject\Address">
- <one-to-one field="user" target-entity="User" inversed-by="address" />
- </entity>
- Required attributes for owning One-to-One:
- - field - Name of the property/field on the entity's PHP class.
- - target-entity - Name of the entity associated entity class. If
- this is not qualified the namespace of the current class is
- prepended. *IMPORTANT:* No leading backslash!
- Optional attributes for owning One-to-One:
- - inversed-by - If the association is bidirectional the
- inversed-by attribute has to be specified with the name of the
- field on the inverse entity that contains the back-reference.
- - orphan-removal - If true, the inverse side entity is always
- deleted when the owning side entity is. Defaults to false.
- - fetch - Either LAZY or EAGER, defaults to LAZY. This attribute
- makes only sense on the owning side, the inverse side *ALWAYS* has
- to use the ``FETCH`` strategy.
- The definition for the owning side relies on a bunch of mapping
- defaults for the join column names. Without the nested
- ``<join-column />`` element Doctrine assumes to foreign key to be
- called ``user_id`` on the Address Entities table. This is because
- the ``MyProject\Address`` entity is the owning side of this
- association, which means it contains the foreign key.
- The completed explicitly defined mapping is:
- .. code-block:: xml
- <entity class="MyProject\Address">
- <one-to-one field="user" target-entity="User" inversed-by="address">
- <join-column name="user_id" referenced-column-name="id" />
- </one-to-one>
- </entity>
- Defining Many-To-One Associations
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- The many-to-one association is *ALWAYS* the owning side of any
- bidirectional association. This simplifies the mapping compared to
- the one-to-one case. The minimal mapping for this association looks
- like:
- .. code-block:: xml
- <entity class="MyProject\Article">
- <many-to-one field="author" target-entity="User" />
- </entity>
- Required attributes:
- - field - Name of the property/field on the entity's PHP class.
- - target-entity - Name of the entity associated entity class. If
- this is not qualified the namespace of the current class is
- prepended. *IMPORTANT:* No leading backslash!
- Optional attributes:
- - inversed-by - If the association is bidirectional the
- inversed-by attribute has to be specified with the name of the
- field on the inverse entity that contains the back-reference.
- - orphan-removal - If true the entity on the inverse side is
- always deleted when the owning side entity is and it is not
- connected to any other owning side entity anymore. Defaults to
- false.
- - fetch - Either LAZY or EAGER, defaults to LAZY.
- This definition relies on a bunch of mapping defaults with regards
- to the naming of the join-column/foreign key. The explicitly
- defined mapping includes a ``<join-column />`` tag nested inside
- the many-to-one association tag:
- .. code-block:: xml
- <entity class="MyProject\Article">
- <many-to-one field="author" target-entity="User">
- <join-column name="author_id" referenced-column-name="id" />
- </many-to-one>
- </entity>
- The join-column attribute ``name`` specifies the column name of the
- foreign key and the ``referenced-column-name`` attribute specifies
- the name of the primary key column on the User entity.
- Defining One-To-Many Associations
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- The one-to-many association is *ALWAYS* the inverse side of any
- association. There exists no such thing as a uni-directional
- one-to-many association, which means this association only ever
- exists for bi-directional associations.
- .. code-block:: xml
- <entity class="MyProject\User">
- <one-to-many field="phonenumbers" target-entity="Phonenumber" mapped-by="user" />
- </entity>
- Required attributes:
- - field - Name of the property/field on the entity's PHP class.
- - target-entity - Name of the entity associated entity class. If
- this is not qualified the namespace of the current class is
- prepended. *IMPORTANT:* No leading backslash!
- - mapped-by - Name of the field on the owning side (here
- Phonenumber entity) that contains the owning side association.
- Optional attributes:
- - fetch - Either LAZY, EXTRA_LAZY or EAGER, defaults to LAZY.
- - index-by: Index the collection by a field on the target entity.
- Defining Many-To-Many Associations
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- From all the associations the many-to-many has the most complex
- definition. When you rely on the mapping defaults you can omit many
- definitions and rely on their implicit values.
- .. code-block:: xml
- <entity class="MyProject\User">
- <many-to-many field="groups" target-entity="Group" />
- </entity>
- Required attributes:
- - field - Name of the property/field on the entity's PHP class.
- - target-entity - Name of the entity associated entity class. If
- this is not qualified the namespace of the current class is
- prepended. *IMPORTANT:* No leading backslash!
- Optional attributes:
- - mapped-by - Name of the field on the owning side that contains
- the owning side association if the defined many-to-many association
- is on the inverse side.
- - inversed-by - If the association is bidirectional the
- inversed-by attribute has to be specified with the name of the
- field on the inverse entity that contains the back-reference.
- - fetch - Either LAZY, EXTRA_LAZY or EAGER, defaults to LAZY.
- - index-by: Index the collection by a field on the target entity.
- The mapping defaults would lead to a join-table with the name
- "User\_Group" being created that contains two columns "user\_id"
- and "group\_id". The explicit definition of this mapping would be:
- .. code-block:: xml
- <entity class="MyProject\User">
- <many-to-many field="groups" target-entity="Group">
- <join-table name="cms_users_groups">
- <join-columns>
- <join-column name="user_id" referenced-column-name="id"/>
- </join-columns>
- <inverse-join-columns>
- <join-column name="group_id" referenced-column-name="id"/>
- </inverse-join-columns>
- </join-table>
- </many-to-many>
- </entity>
- Here both the ``<join-columns>`` and ``<inverse-join-columns>``
- tags are necessary to tell Doctrine for which side the specified
- join-columns apply. These are nested inside a ``<join-table />``
- attribute which allows to specify the table name of the
- many-to-many join-table.
- Cascade Element
- ~~~~~~~~~~~~~~~
- Doctrine allows cascading of several UnitOfWork operations to
- related entities. You can specify the cascade operations in the
- ``<cascade />`` element inside any of the association mapping
- tags.
- .. code-block:: xml
- <entity class="MyProject\User">
- <many-to-many field="groups" target-entity="Group">
- <cascade>
- <cascade-all/>
- </cascade>
- </many-to-many>
- </entity>
- Besides ``<cascade-all />`` the following operations can be
- specified by their respective tags:
- - ``<cascade-persist />``
- - ``<cascade-merge />``
- - ``<cascade-remove />``
- - ``<cascade-refresh />``
- Join Column Element
- ~~~~~~~~~~~~~~~~~~~
- In any explicitly defined association mapping you will need the
- ``<join-column />`` tag. It defines how the foreign key and primary
- key names are called that are used for joining two entities.
- Required attributes:
- - name - The column name of the foreign key.
- - referenced-column-name - The column name of the associated
- entities primary key
- Optional attributes:
- - unique - If the join column should contain a UNIQUE constraint.
- This makes sense for Many-To-Many join-columns only to simulate a
- one-to-many unidirectional using a join-table.
- - nullable - should the join column be nullable, defaults to true.
- - on-delete - Foreign Key Cascade action to perform when entity is
- deleted, defaults to NO ACTION/RESTRICT but can be set to
- "CASCADE".
- Defining Order of To-Many Associations
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- You can require one-to-many or many-to-many associations to be
- retrieved using an additional ``ORDER BY``.
- .. code-block:: xml
- <entity class="MyProject\User">
- <many-to-many field="groups" target-entity="Group">
- <order-by>
- <order-by-field name="name" direction="ASC" />
- </order-by>
- </many-to-many>
- </entity>
- Defining Indexes or Unique Constraints
- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- To define additional indexes or unique constraints on the entities
- table you can use the ``<indexes />`` and
- ``<unique-constraints />`` elements:
- .. code-block:: xml
- <entity name="Doctrine\Tests\ORM\Mapping\User" table="cms_users">
-
- <indexes>
- <index name="name_idx" columns="name"/>
- <index columns="user_email"/>
- </indexes>
-
- <unique-constraints>
- <unique-constraint columns="name,user_email" name="search_idx" />
- </unique-constraints>
- </entity>
- You have to specify the column and not the entity-class field names
- in the index and unique-constraint definitions.
- Derived Entities ID syntax
- ~~~~~~~~~~~~~~~~~~~~~~~~~~
- If the primary key of an entity contains a foreign key to another entity we speak of a derived
- entity relationship. You can define this in XML with the "association-key" attribute in the ``<id>`` tag.
- .. code-block:: xml
- <doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping
- http://raw.github.com/doctrine/doctrine2/master/doctrine-mapping.xsd">
- <entity name="Application\Model\ArticleAttribute">
- <id name="article" association-key="true" />
- <id name="attribute" type="string" />
- <field name="value" type="string" />
- <many-to-one field="article" target-entity="Article" inversed-by="attributes" />
- <entity>
- </doctrine-mapping>
|