Changeset 4653 for trunk/lib/Doctrine

Timestamp:

07/10/08 18:17:58 (6 months ago)

Author:

romanb

Message:

Refactorings. Merged hydrator fixes from 0.11/1.0

Location:

trunk/lib/Doctrine

Files:

• ClassMetadata.php (modified) (33 diffs)
• ClassMetadata/CodeDriver.php (modified) (1 diff)
• ClassMetadata/Factory.php (modified) (6 diffs)
• Connection/UnitOfWork.php (modified) (5 diffs)
• Entity.php (modified) (34 diffs)
• EntityManager.php (modified) (15 diffs)
• EntityPersister/Abstract.php (modified) (4 diffs)
• EntityPersister/JoinedSubclass.php (modified) (4 diffs)
• EntityRepository.php (modified) (2 diffs)
• EventListener.php (modified) (1 diff)
• EventManager.php (modified) (1 diff)
• HydratorNew.php (modified) (5 diffs)
• Query/Production/IndexBy.php (modified) (1 diff)

trunk/lib/Doctrine/ClassMetadata.php

@@ -25 +25 @@
  * A <tt>ClassMetadata</tt> instance holds all the information (metadata) of an entity and
  * it's associations and how they're mapped to the relational database.
+ * It is the backbone of Doctrine's metadata mapping.
  *
- * @package Doctrine
- * @subpackage ClassMetadata
  * @author Roman Borschel <roman@code-factory.org>
  * @since 2.0
@@ -116 +115 @@
 
     /**
-     * The mapped columns and their mapping definitions.
-     * Keys are column names and values are mapping definitions.
+     * The field mappings of the class.
+     * Keys are field names and values are mapping definitions.
      *
      * The mapping definition array has at least the following values:
@@ -129 +128 @@
      *  ... many more
      *
-     * @var array $columns
-     */
-    protected $_mappedColumns = array();
+     * @var array
+     */    
+    protected $_fieldMappings = array();
     
     /**
@@ -283 +282 @@
      */
     protected $_invokedMethods = array();
-
+    
+    /**
+     * The cached lifecycle listeners. There is only one instance of each
+     * listener class at any time.
+     *
+     * @var array
+     */
+    protected $_lifecycleListenerInstances = array();
+
+    /**
+     * The registered lifecycle callbacks for Entities of this class.
+     *
+     * @var array
+     */
+    protected $_lifecycleCallbacks = array();
+    
+    /**
+     * The registered lifecycle listeners for Entities of this class.
+     *
+     * @var array
+     */
+    protected $_lifecycleListeners = array();
+    
 
     /**
@@ -375 +396 @@
     public function isUniqueField($fieldName)
     {
-        $mapping = $this->getColumnMapping($fieldName);
+        $mapping = $this->getFieldMapping($fieldName);
 
         if ($mapping !== false) {
@@ -392 +413 @@
     public function isNotNull($fieldName)
     {
-        $mapping = $this->getColumnMapping($fieldName);
+        $mapping = $this->getFieldMapping($fieldName);
 
         if ($mapping !== false) {
@@ -532 +553 @@
     {
         return isset($this->_columnNames[$fieldName]) ?
-        $this->_columnNames[$fieldName] : $fieldName;
+                $this->_columnNames[$fieldName] : $fieldName;
     }
 
@@ -543 +564 @@
     }
 
-    public function getColumnMapping($columnName)
-    {
-        return isset($this->_mappedColumns[$columnName]) ?
-                $this->_mappedColumns[$columnName] : false;
+    public function getFieldMapping($fieldName)
+    {
+        return isset($this->_fieldMappings[$fieldName]) ?
+                $this->_fieldMappings[$fieldName] : false;
     }
 
@@ -594 +615 @@
      * This lookup on subclasses is costly but happens only *once* for a column
      * during hydration because the hydrator caches effectively.
+     * 
+     * @return string  The field name.
+     * @throws Doctrine::ORM::Exceptions::ClassMetadataException if the field name could
+     *         not be found.
      */
     public function lookupFieldName($lcColumnName)
@@ -627 +652 @@
 
     /**
-     * Maps a column of the class' database table to a field of the entity.
+     * Maps a field of the class to a database column.
      *
      * @param string $name      The name of the column to map. Syntax: columnName [as propertyName].
@@ -640 +665 @@
      * @throws Doctrine_ClassMetadata_Exception If trying use wrongly typed parameter.
      */
-    public function mapColumn($name, $type, $length = null, $options = array(), $prepend = false)
+    public function mapColumn($name, $type, $length = null, $options = array())
     {
         // converts 0 => 'primary' to 'primary' => true etc.
@@ -662 +687 @@
         $lcColumnName = strtolower($parts[0]);
 
-        if (isset($this->_mappedColumns[$columnName])) {
+        if (isset($this->_fieldMappings[$fieldName])) {
             return;
         }
 
         // Fill column name <-> field name lookup maps
-        if ($prepend) {
-            $this->_columnNames = array_merge(array($fieldName => $columnName), $this->_columnNames);
-            $this->_fieldNames = array_merge(array($columnName => $fieldName), $this->_fieldNames);
-        } else {
-            $this->_columnNames[$fieldName] = $columnName;
-            $this->_fieldNames[$columnName] = $fieldName;
-        }
+        $this->_columnNames[$fieldName] = $columnName;
+        $this->_fieldNames[$columnName] = $fieldName;
+        $this->_lcColumnToFieldNames[$lcColumnName] = $fieldName;
         $this->_lcColumnToFieldNames[$lcColumnName] = $fieldName;
         
@@ -702 +723 @@
         }*/
 
-        if ($prepend) {
-            $this->_mappedColumns = array_merge(array($columnName => $options), $this->_mappedColumns);
-        } else {
-            $this->_mappedColumns[$columnName] = $options;
-        }
+        $this->_fieldMappings[$fieldName] = $options;
 
         $this->_columnCount++;
@@ -755 +772 @@
 
     /**
-     * setColumn
-     *
-     * @param string $name
-     * @param string $type
-     * @param integer $length
-     * @param mixed $options
-     * @param boolean $prepend   Whether to prepend or append the new column to the column list.
-     *                           By default the column gets appended.
-     * @throws Doctrine_Table_Exception     if trying use wrongly typed parameter
-     * @return void
-     * @deprecated Use mapColumn()
-     */
-    public function setColumn($name, $type, $length = null, $options = array(), $prepend = false)
-    {
-        return $this->mapColumn($name, $type, $length, $options, $prepend);
-    }
-
-    /**
      * Gets the names of all validators that are applied on a field.
      *
@@ -780 +779 @@
     public function getFieldValidators($fieldName)
     {
-        $columnName = $this->getColumnName($fieldName);
-        return isset($this->_mappedColumns[$columnName]['validators']) ?
-        $this->_mappedColumns[$columnName]['validators'] : array();
+        return isset($this->_fieldMappings[$fieldName]['validators']) ?
+                $this->_fieldMappings[$fieldName]['validators'] : array();
     }
 
@@ -804 +802 @@
     public function getDefaultValueOf($fieldName)
     {
-        $columnName = $this->getColumnName($fieldName);
-        if ( ! isset($this->_mappedColumns[$columnName])) {
-            throw new Doctrine_Table_Exception("Couldn't get default value. Column ".$columnName." doesn't exist.");
-        }
-        if (isset($this->_mappedColumns[$columnName]['default'])) {
-            return $this->_mappedColumns[$columnName]['default'];
+        if ( ! isset($this->_fieldMappings[$fieldName])) {
+            throw new Doctrine_Table_Exception("Couldn't get default value. Column ".$fieldName." doesn't exist.");
+        }
+        if (isset($this->_fieldMappings[$fieldName]['default'])) {
+            return $this->_fieldMappings[$fieldName]['default'];
         } else {
             return null;
@@ -868 +865 @@
     public function hasColumn($columnName)
     {
-        return isset($this->_mappedColumns[$columnName]);
+        return isset($this->_fieldNames[$columnName]);
     }
 
     public function hasMappedColumn($columnName)
     {
-        return isset($this->_mappedColumns[$columnName]);
+        return isset($this->_fieldNames[$columnName]);
     }
 
@@ -891 +888 @@
     public function getEnumValues($fieldName)
     {
-        $columnName = $this->getColumnName($fieldName);
-        if (isset($this->_mappedColumns[$columnName]['values'])) {
-            return $this->_mappedColumns[$columnName]['values'];
+        if (isset($this->_fieldMappings[$fieldName]['values'])) {
+            return $this->_fieldMappings[$fieldName]['values'];
         } else {
             return array();
@@ -918 +914 @@
         $columnName = $this->getColumnName($fieldName);
         if ( ! $this->_em->getAttribute(Doctrine::ATTR_USE_NATIVE_ENUM) &&
-        isset($this->_mappedColumns[$columnName]['values'][$index])) {
-            $enumValue = $this->_mappedColumns[$columnName]['values'][$index];
+                isset($this->_fieldMappings[$fieldName]['values'][$index])) {
+            $enumValue = $this->_fieldMappings[$fieldName]['values'][$index];
         } else {
             $enumValue = $index;
@@ -974 +970 @@
     public function getCustomAccessor($fieldName)
     {
-        $columnName = $this->getColumnName($fieldName);
-        return isset($this->_mappedColumns[$columnName]['accessor']) ?
-                $this->_mappedColumns[$columnName]['accessor'] : null;
+        return isset($this->_fieldMappings[$fieldName]['accessor']) ?
+                $this->_fieldMappings[$fieldName]['accessor'] : null;
     }
 
@@ -986 +981 @@
     public function getCustomMutator($fieldName)
     {
-        $columnName = $this->getColumnName($fieldName);
-        return isset($this->_mappedColumns[$columnName]['mutator']) ?
-                $this->_mappedColumns[$columnName]['mutator'] : null;
+        return isset($this->_fieldMappings[$fieldName]['mutator']) ?
+                $this->_fieldMappings[$fieldName]['mutator'] : null;
     }
 
@@ -999 +993 @@
     public function getColumns()
     {
-        return $this->_mappedColumns;
+        return $this->_fieldMappings;
     }
 
@@ -1009 +1003 @@
     public function getMappedColumns()
     {
-        return $this->_mappedColumns;
+        return $this->_fieldMappings;
+    }
+    
+    public function getFieldMappings()
+    {
+        return $this->_fieldMappings;
     }
 
@@ -1024 +1023 @@
         unset($this->_fieldNames[$columnName]);
 
-        if (isset($this->_mappedColumns[$columnName])) {
-            unset($this->_mappedColumns[$columnName]);
+        if (isset($this->_fieldMappings[$fieldName])) {
+            unset($this->_fieldMappings[$fieldName]);
             return true;
         }
@@ -1041 +1040 @@
     {
         if ($fieldNames === null) {
-            return array_keys($this->_mappedColumns);
+            return array_keys($this->_fieldNames);
         } else {
             $columnNames = array();
@@ -1093 +1092 @@
     public function getMappingForField($fieldName)
     {
-        $columnName = $this->getColumnName($fieldName);
-        return $this->getColumnDefinition($columnName);
+        return $this->_fieldMappings[$fieldName];
     }
 
@@ -1105 +1103 @@
     public function getTypeOf($fieldName)
     {
+        
         return $this->getTypeOfColumn($this->getColumnName($fieldName));
     }
@@ -1116 +1115 @@
     public function getTypeOfField($fieldName)
     {
-        return $this->getTypeOfColumn($this->getColumnName($fieldName));
+        return isset($this->_fieldMappings[$fieldName]) ?
+                $this->_fieldMappings[$fieldName]['type'] : false;
     }
 
@@ -1126 +1126 @@
     public function getTypeOfColumn($columnName)
     {
-        return isset($this->_mappedColumns[$columnName]) ? $this->_mappedColumns[$columnName]['type'] : false;
+        return $this->getTypeOfField($this->getFieldName($columnName));
     }
 
@@ -1134 +1134 @@
     public function getFieldLength($fieldName)
     {
-        return $this->_mappedColumns[$this->getColumnName($fieldName)]['length'];
+        return $this->_fieldMappings[$fieldName]['length'];
     }
 
@@ -1503 +1503 @@
         $options['foreignKeys'] = array();
         if ($parseForeignKeys && $this->getAttribute(Doctrine::ATTR_EXPORT)
-        & Doctrine::EXPORT_CONSTRAINTS) {
+                & Doctrine::EXPORT_CONSTRAINTS) {
             $constraints = array();
             $emptyIntegrity = array('onUpdate' => null, 'onDelete' => null);
@@ -1684 +1684 @@
     public function isInheritedField($fieldName)
     {
-        return isset($this->_mappedColumns[$this->getColumnName($fieldName)]['inherited']);
+        return isset($this->_fieldMappings[$fieldName]['inherited']);
     }
 
@@ -1913 +1913 @@
 
     }
+    
+    /**
+     * Dispatches the lifecycle event of the given Entity to the registered
+     * lifecycle callbacks and lifecycle listeners.
+     *
+     * @param string $event  The lifecycle event.
+     * @param Entity $entity  The Entity on which the event occured.
+     */
+    public function invokeLifecycleCallbacks($lifecycleEvent, Doctrine_Entity $entity)
+    {
+        foreach ($this->getLifecycleCallbacks($lifecycleEvent) as $callback) {
+            $entity->$callback();
+        }
+        foreach ($this->getLifecycleListeners($lifecycleEvent) as $className => $callback) {
+            if ( ! isset($this->_lifecycleListenerInstances[$className])) {
+                $this->_lifecycleListenerInstances[$className] = new $className;
+            }
+            $this->_lifecycleListenerInstances[$className]->$callback($entity);
+        }
+    }
+    
+    /**
+     * Gets the registered lifecycle callbacks for an event.
+     *
+     * @param string $event
+     * @return array
+     */
+    public function getLifecycleCallbacks($event)
+    {
+        return isset($this->_lifecycleCallbacks[$event]) ?
+                $this->_lifecycleCallbacks[$event] : array();
+    }
+    
+    /**
+     * Gets the registered lifecycle listeners for an event.
+     *
+     * @param string $event
+     * @return array
+     */
+    public function getLifecycleListeners($event)
+    {
+        return isset($this->_lifecycleListeners[$event]) ?
+                $this->_lifecycleListeners[$event] : array();
+    }
+    
+    /**
+     * Adds a lifecycle listener for Entities this class.
+     * 
+     * Note: If the same listener class is registered more than once, the old
+     * one will be overridden.
+     *
+     * @param string $listenerClass
+     * @param array $callbacks
+     */
+    public function addLifecycleListener($listenerClass, array $callbacks)
+    {
+        $this->_lifecycleListeners[$event][$listenerClass] = array();
+        foreach ($callbacks as $method => $event) {
+            $this->_lifecycleListeners[$event][$listenerClass][] = $method;
+        }
+    }
+    
+    /**
+     * Adds a lifecycle callback for Entities of this class.
+     *
+     * Note: If a the same callback is registered more than once, the old one
+     * will be overridden.
+     * 
+     * @param string $callback
+     * @param string $event
+     */
+    public function addLifecycleCallback($callback, $event)
+    {
+        if ( ! isset($this->_lifecycleCallbacks[$event])) {
+            $this->_lifecycleCallbacks[$event] = array();
+        }
+        if ( ! in_array($callback, $this->_lifecycleCallbacks[$event])) {
+            $this->_lifecycleCallbacks[$event][$callback] = $callback;
+        } 
+    }
 
     /**

trunk/lib/Doctrine/ClassMetadata/CodeDriver.php

@@ -36 +36 @@
 {
     /**
+     * Name of the callback method.
+     * 
+     * @todo We could make the name of the callback methods customizable for users.
+     */
+    const CALLBACK_METHOD = 'initMetadata';
+    
+    /**
      * Loads the metadata for the specified class into the provided container.
      */
     public function loadMetadataForClass($className, Doctrine_ClassMetadata $metadata)
     {
-        if ( ! method_exists($className, 'initMetadata')) {
+        if ( ! method_exists($className, self::CALLBACK_METHOD)) {
             throw new Doctrine_ClassMetadata_Exception("Unable to load metadata for class"
                     . " '$className'. Callback method 'initMetadata' not found.");

trunk/lib/Doctrine/ClassMetadata/Factory.php

@@ -134 +134 @@
             $fullName = "$name as " . $parentClass->getFieldName($name);
             $definition['inherited'] = true;
-            $subClass->mapColumn($fullName, $definition['type'], $definition['length'],
+            $subClass->mapColumn(
+                    $fullName,
+                    $definition['type'],
+                    $definition['length'],
                     $definition);
         }
@@ -155 +158 @@
     {
         if ( ! class_exists($name) || empty($name)) {
-            /*try {
-                throw new Exception();
-            } catch (Exception $e) {
-                echo $e->getTraceAsString();
-            }*/
             throw new Doctrine_Exception("Couldn't find class " . $name . ".");
         }
@@ -176 +174 @@
 
         if ($className === false) {
-            try {
-                throw new Exception();
-            } catch (Exception $e) {
-                echo $e->getTraceAsString() . "<br />";
-            }
             throw new Doctrine_ClassMetadata_Factory_Exception("Unknown component '$className'.");
         }
@@ -208 +201 @@
     {
         switch (count((array)$class->getIdentifier())) {
-            case 0:
+            case 0: // No identifier in the class mapping yet
+                
+                // If its a subclass, inherit the identifier from the parent.
                 if ($class->getInheritanceType() == Doctrine::INHERITANCE_TYPE_JOINED &&
-                        count($class->getParentClasses()) > 0) {
-                            
+                        count($class->getParentClasses()) > 0) {       
                     $parents = $class->getParentClasses();
                     $root = end($parents);
@@ -238 +232 @@
                     }
                 } else {
+                    throw Doctrine_MappingException::identifierRequired($class->getClassName());      
+                    /* Legacy behavior of auto-adding an id field
                     $definition = array('type' => 'integer',
                                         'length' => 20,
                                         'autoincrement' => true,
                                         'primary' => true);
-                    $class->setColumn('id', $definition['type'], $definition['length'], $definition, true);
+                    $class->mapColumn('id', $definition['type'], $definition['length'], $definition, true);
                     $class->setIdentifier(array('id'));
                     $class->setIdentifierType(Doctrine::IDENTIFIER_AUTOINC);
+                    */
                 }
                 break;
-            case 1:
-                foreach ((array)$class->getIdentifier() as $pk) {
+            case 1: // A single identifier is in the mapping
+                foreach ($class->getIdentifier() as $pk) {
                     $columnName = $class->getColumnName($pk);
                     $thisColumns = $class->getColumns();
@@ -295 +292 @@
 
                 break;
-            default:
+            default: // Multiple identifiers are in the mapping so its a composite id
                 $class->setIdentifierType(Doctrine::IDENTIFIER_COMPOSITE);
         }

trunk/lib/Doctrine/Connection/UnitOfWork.php

@@ -84 +84 @@
     
     /**
-     * The EntityManager the unit of work belongs to.
+     * The EntityManager the UnitOfWork belongs to.
      */
     protected $_em;
@@ -99 +99 @@
     /**
      * Constructor.
-     * Created a new UnitOfWork.
+     * Creates a new UnitOfWork.
      *
      * @param Doctrine_EntityManager $em
@@ -111 +111 @@
      * Commits the unit of work, executing all operations that have been postponed
      * up to this point.
-     *
+     * 
+     * @todo Impl
      */
     public function commit()
@@ -192 +193 @@
     public function registerRemoved(Doctrine_Entity $entity)
     {
-        if ($entity->isTransient()) {
+        if ($entity->isNew()) {
             return;
         }
@@ -512 +513 @@
     }
     
+    public function save(Doctrine_Entity $entity)
+    {        
+        switch ($entity->_state()) {
+            case Doctrine_Entity::STATE_CLEAN:
+                //nothing to do
+                // ignore $entity but cascade
+                break;
+            case Doctrine_Entity::STATE_DIRTY:
+                // update
+                $this->registerDirty($entity);
+                // todo:cascade
+                break;
+            case Doctrine_Entity::STATE_TCLEAN:
+            case Doctrine_Entity::STATE_TDIRTY:
+                // insert
+                // if identifier type IDENTITY:
+                //     cascade
+                //     if no transaction is started yet, do it
+                //     force insert (directly to persister)
+                // else
+                //     cascade
+                //     get & assign the identifier, then registerNew()
+                break;
+        }
+    }
+  &