Add ODM embedded-like functionality

lib/Doctrine/ORM/Internal/Hydration/SimpleObjectHydrator.php

@@ -158,10 +158,12 @@ protected function hydrateColumnInfo($entityName, $column)
                     return null;
                 }
 
+                $field = isset($class->mappedAssociationMappings[$this->_rsm->fieldMappings[$column]]) ? null : true;
+
                 return array(
                     'class' => $class,
                     'name'  => $this->_rsm->fieldMappings[$column],
-                    'field' => true,
+                    'field' => $field,
                 );
 
             case (isset($this->_rsm->relationMap[$column])):

lib/Doctrine/ORM/Mapping/ClassMetadataInfo.php

@@ -373,6 +373,13 @@ class ClassMetadataInfo implements ClassMetadata
      */
     public $columnNames = array();
 
+    /**
+     * READ-ONLY: The mapped associations of the class.
+     *
+     * @var array
+     */
+    public $mappedAssociations = array();
+
     /**
      * READ-ONLY: The discriminator value of this class.
      *
@@ -816,6 +823,10 @@ public function __sleep()
             $serialized[] = "customGeneratorDefinition";
         }
 
+        if ($this->mappedAssociations) {
+            $serialized[] = "mappedAssociations";
+        }
+
         return $serialized;
     }
 
@@ -854,6 +865,10 @@ public function wakeupReflection($reflService)
                 ? $reflService->getAccessibleProperty($mapping['declared'], $field)
                 : $reflService->getAccessibleProperty($this->name, $field);
         }
+
+        foreach ($this->mappedAssociations as $field => $mapping) {
+            $this->reflFields[$field] = $reflService->getAccessibleProperty($this->name, $field);
+        }
     }
 
     /**
@@ -2083,6 +2098,45 @@ public function addInheritedFieldMapping(array $fieldMapping)
         $this->fieldNames[$fieldMapping['columnName']] = $fieldMapping['fieldName'];
     }
 
+    /**
+     * Add a mapped association to the class
+     *
+     * @param array $mapping
+     *
+     * @throws MappingException
+     */
+    public function addMappedAssociation(array $mapping)
+    {
+        $fieldMapping = &$mapping['fieldMapping'];
+
+        if (!isset($fieldMapping['columnName'])) {
+            $fieldMapping['fieldName'] = $mapping['name'] . 'Class';
+            $fieldMapping['columnName'] = $this->namingStrategy->propertyToColumnName($fieldMapping['fieldName']);
+        } else {
+            $fieldMapping['fieldName'] = $fieldMapping['columnName'];
+        }
+
+        if ($fieldMapping['columnName'][0] === '`') {
+            $fieldMapping['columnName']  = trim($fieldMapping['columnName'], '`');
+            $fieldMapping['quoted']      = true;
+        }
+
+        $fieldMapping['type'] = 'string';
+
+        if (isset($this->fieldNames[$fieldMapping['columnName']])) {
+            throw MappingException::duplicateColumnName($this->name, $fieldMapping['columnName']);
+        }
+
+        if (!isset($this->associationMappings[$mapping['name']])) {
+            throw MappingException::associationRequiredForMappedAssociation($this->name, $fieldMapping['columnName']);
+        } elseif ($this->associationMappings[$mapping['name']]['type'] != self::ONE_TO_ONE || $this->associationMappings[$mapping['name']]['isOwningSide']) {
+            throw MappingException::unsupportedAssociationForMappedAssociation($this->name, $fieldMapping['columnName']);
+        }
+
+        $this->mappedAssociationMappings[$fieldMapping['columnName']] = $mapping['name'];
+        $this->mappedAssociations[$mapping['name']] = $mapping;
+    }
+
     /**
      * INTERNAL:
      * Adds a named query to this class.
@@ -2467,6 +2521,26 @@ public function hasSqlResultSetMapping($name)
         return isset($this->sqlResultSetMappings[$name]);
     }
 
+    /**
+     * Checks whether the class has any mapped associations.
+     *
+     * @return array
+     */
+    public function hasMappedAssociations()
+    {
+        return $this->mappedAssociations;
+    }
+
+    /**
+     * Return array of all mapped associations of the class.
+     *
+     * @return array
+     */
+    public function getMappedAssociations()
+    {
+        return $this->mappedAssociations;
+    }
+
     /**
      * {@inheritDoc}
      */

lib/Doctrine/ORM/Mapping/DefaultQuoteStrategy.php

@@ -40,12 +40,22 @@ public function getColumnName($fieldName, ClassMetadata $class, AbstractPlatform
             : $class->fieldMappings[$fieldName]['columnName'];
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function getMappedAssociationDiscriminatorColumnName(array $assoc, ClassMetadata $class, AbstractPlatform $platform)
+    {
+        return isset($assoc['fieldMapping']['quoted'])
+            ? $platform->quoteIdentifier($assoc['fieldMapping']['columnName'])
+            : $assoc['fieldMapping']['columnName'];
+    }
+
     /**
      * {@inheritdoc}
      */
     public function getTableName(ClassMetadata $class, AbstractPlatform $platform)
     {
-        return isset($class->table['quoted']) 
+        return isset($class->table['quoted'])
             ? $platform->quoteIdentifier($class->table['name'])
             : $class->table['name'];
     }
@@ -137,4 +147,4 @@ public function getColumnAlias($columnName, $counter, AbstractPlatform $platform
         return $platform->getSQLResultCasing($columnName);
     }
 
-}
+}

lib/Doctrine/ORM/Mapping/Driver/AnnotationDriver.php

@@ -400,6 +400,18 @@ public function loadMetadataForClass($className, ClassMetadata $metadata)
 
                 $metadata->mapManyToMany($mapping);
             }
+
+            // Evaluate MappedAssociation annotation
+            $mappedAssociation = array();
+            if ($mappedAssocAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\MappedAssociation')) {
+                $mappedAssociation['name'] = $property->getName();
+                $mappedAssociation['fieldMapping'] = array (
+                    'columnName' => $mappedAssocAnnot->discriminatorColumn,
+                    'length'     => $mappedAssocAnnot->length,
+                    'nullable'   => $mappedAssocAnnot->nullable,
+                );
+                $metadata->addMappedAssociation($mappedAssociation);
+            }
         }
 
         // Evaluate AssociationOverrides annotation

lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php

@@ -64,3 +64,4 @@
 require_once __DIR__.'/../AssociationOverrides.php';
 require_once __DIR__.'/../AttributeOverride.php';
 require_once __DIR__.'/../AttributeOverrides.php';
+require_once __DIR__.'/../MappedAssociation.php';

lib/Doctrine/ORM/Mapping/MappedAssociation.php

@@ -0,0 +1,36 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\ORM\Mapping;
+
+/**
+ * @Annotation
+ * @Target("PROPERTY")
+ */
+final class MappedAssociation implements Annotation
+{
+    /** @var string */
+    public $discriminatorColumn;
+
+    /** @var integer */
+    public $length = 255;
+
+    /** @var boolean */
+    public $nullable = true;
+}

lib/Doctrine/ORM/Mapping/MappingException.php

@@ -438,4 +438,26 @@ public static function invalidCascadeOption(array $cascades, $className, $proper
             $cascades
         ));
     }
+
+    /**
+     * @param string $className
+     * @param string $field
+     *
+     * @return self
+     */
+    public static function associationRequiredForMappedAssociation($className, $field)
+    {
+        return new self("One-to-one association required on '$className#$field' for mapped association.");
+    }
+
+    /**
+     * @param string $className
+     * @param string $field
+     *
+     * @return self
+     */
+    public static function unsupportedAssociationForMappedAssociation($className, $field)
+    {
+        return new self("Invalid association type on '$className#$field' for mapped association. Only one-to-one associations are supported with the mapped entity reusing the primary key.");
+    }
 }

lib/Doctrine/ORM/Mapping/QuoteStrategy.php

@@ -109,4 +109,15 @@ function getIdentifierColumnNames(ClassMetadata $class, AbstractPlatform $platfo
      */
     function getColumnAlias($columnName, $counter, AbstractPlatform $platform, ClassMetadata $class = null);
 
-}
+    /**
+     * Gets the (possibly quoted) mapped association discriminator column name
+     *
+     * @param array            $assoc
+     * @param ClassMetadata    $class
+     * @param AbstractPlatform $platform
+     *
+     * @return string
+     */
+    function getMappedAssociationDiscriminatorColumnName(array $assoc, ClassMetadata $class, AbstractPlatform $platform);
+
+}