Merged r3518:r3700 from branch to trunk. Branch to be deleted, soon....

Merged r3518:r3700 from branch to trunk. Branch to be deleted, soon. Development continues in trunk.

lib/Doctrine/ClassMetadata/CodeDriver.php

+<?php 
+
+/**
+ * The code metadata driver loads the metadata of the classes through invoking 
+ * a static callback method that needs to be implemented when using this driver.
+ *
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class Doctrine_ClassMetadata_CodeDriver
+{
+    /**
+     * Loads the metadata for the specified class into the provided container.
+     */
+    public function loadMetadataForClass($className, Doctrine_ClassMetadata $metadata)
+    {
+        call_user_func_array(array($className, 'initMetadata'), array($metadata));
+    }   
+}
\ No newline at end of file

lib/Doctrine/ClassMetadata/Exception.php

+<?php 
+
+class Doctrine_ClassMetadata_Exception extends Doctrine_Exception {}
\ No newline at end of file

lib/Doctrine/ClassMetadata/YamlDriver.php

+<?php 
+
+/**
+ * The yaml driver loads metadata informations about classes from .yml files.
+ *
+ */
+class Doctrine_ClassMetadata_YamlDriver
+{
+    /**
+     * 
+     */
+    public function loadMetadataForClass($className, Doctrine_ClassMetadata $metadata)
+    {
+        throw new Doctrine_ClassMetadata_Exception("YAML driver not yet implemented.");
+    }   
+}
\ No newline at end of file

lib/Doctrine/Column.php

-<?php
-/*
- *  $Id$
- *
- * 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 LGPL. For more information, see
- * <http://www.phpdoctrine.org>.
- */
-
-/**
- * Doctrine_Column
- * This class represents a database column
- *
- * @author      Konsta Vesterinen <kvesteri@cc.hut.fi>
- * @package     Doctrine
- * @subpackage  Column
- * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
- * @version     $Revision$
- * @link        www.phpdoctrine.com
- * @since       1.0
- */
-class Doctrine_Column extends Doctrine_Access implements IteratorAggregate, Countable
-{
-    /**
-     * @var array $definition
-     */
-    protected $_definition = array(
-                                'type'    => null,
-                                'length'  => 0,
-                                );
-
-    /**
-     * @var array $definition
-     */
-    public function __construct(array $definition = array())
-    {
-        $this->_definition = $definition;
-    }
-
-    /**
-     * @return array
-     */
-    public function getDefinition()
-    {
-        return $this->_definition;
-    }
-
-    /**
-     * contains
-     *
-     * @return boolean
-     */
-    public function contains($name) 
-    {
-        return isset($this->_definition[$name]);
-    }
-
-    /**
-     * get
-     *
-     * @param string $name
-     * @return mixed
-     */
-    public function get($name)
-    {
-        if ( ! isset($this->_definition[$name])) {
-            return null;
-        }
-        
-        return $this->_definition[$name];
-    }
-
-    /**
-     * set
-     *
-     * @param string $name
-     * @return mixed
-     */
-    public function set($name, $value)
-    {
-        $this->_definition[$name] = $value;
-    }
-
-    /**
-     * @param string $field
-     * @return array
-     */
-    public function getEnumValues()
-    {
-        if (isset($this->_definition['values'])) {
-            return $this->_definition['values'];
-        } else {
-            return array();
-        }
-    }
-
-    /**
-     * enumValue
-     *
-     * @param string $field
-     * @param integer $index
-     * @return mixed
-     */
-    public function enumValue($index)
-    {
-        if ($index instanceof Doctrine_Null) {
-            return $index;
-        }
-
-        return isset($this->_definition['values'][$index]) ? $this->_definition['values'][$index] : $index;
-    }
-
-    /**
-     * enumIndex
-     *
-     * @param string $field
-     * @param mixed $value
-     * @return mixed
-     */
-    public function enumIndex($field, $value)
-    {
-        $values = $this->getEnumValues($field);
-
-        return array_search($value, $values);
-    }
-
-    /**
-     * count
-     *
-     * @return integer
-     */
-    public function count()
-    {
-        return count($this->_definition);
-    }
-
-    /**
-     * getIterator
-     *
-     * @return ArrayIterator
-     */
-    public function getIterator() 
-    {
-        return new ArrayIterator($this->_definition);
-    }
-}
\ No newline at end of file

lib/Doctrine/Configurable.php

@@ -111,8 +111,8 @@ abstract class Doctrine_Configurable extends Doctrine_Locator_Injectable
                 $this->setEventListener($value);
                 break;
             case Doctrine::ATTR_COLL_KEY:
-                if ( ! ($this instanceof Doctrine_Table)) {
-                    throw new Doctrine_Exception("This attribute can only be set at table level.");
+                if ( ! ($this instanceof Doctrine_ClassMetadata)) {
+                    throw new Doctrine_Exception("This attribute can only be set at class level.");
                 }
                 if ($value !== null && ! $this->hasField($value)) {
                     throw new Doctrine_Exception("Couldn't set collection key attribute. No such field '$value'");
@@ -320,6 +320,11 @@ abstract class Doctrine_Configurable extends Doctrine_Locator_Injectable
 
         return $this;
     }
+    /*
+    public function removeRecordListeners()
+    {
+        $this->attributes[Doctrine::ATTR_RECORD_LISTENER] = 
+    }*/
 
     /**
      * addListener
@@ -364,8 +369,7 @@ abstract class Doctrine_Configurable extends Doctrine_Locator_Injectable
     public function setListener($listener)
     {
         if ( ! ($listener instanceof Doctrine_EventListener_Interface)
-            && ! ($listener instanceof Doctrine_Overloadable)
-        ) {
+                && ! ($listener instanceof Doctrine_Overloadable)) {
             throw new Doctrine_EventListener_Exception("Couldn't set eventlistener. EventListeners should implement either Doctrine_EventListener_Interface or Doctrine_Overloadable");
         }
         $this->attributes[Doctrine::ATTR_LISTENER] = $listener;

lib/Doctrine/Export.php

@@ -1068,7 +1068,7 @@ class Doctrine_Export extends Doctrine_Connection_Module
      * @return void
      */
     public function exportClasses(array $classes)
-    {
+    { 
         $connections = array();
         foreach ($classes as $class) {
             $record = new $class();
@@ -1083,6 +1083,7 @@ class Doctrine_Export extends Doctrine_Connection_Module
             }
 
             $sql = $this->exportClassesSql(array($class));
+
             // Build array of all the creates
             // We need these to happen first
             foreach ($sql as $key => $query) {
@@ -1137,29 +1138,37 @@ class Doctrine_Export extends Doctrine_Connection_Module
      *                                          occurred during the create table operation
      * @param array $classes
      * @return void
+     * @todo package:orm
      */
     public function exportClassesSql(array $classes)
     {
         $models = Doctrine::filterInvalidModels($classes);
 
         $sql = array();
-
+        $finishedClasses = array();
+        
         foreach ($models as $name) {
-            $record = new $name();
-            $table  = $record->getTable();
-
-            $parents = $table->getOption('joinedParents');
-
-            foreach ($parents as $parent) {
-                $data  = $table->getConnection()->getTable($parent)->getExportableFormat();
-
-                $query = $this->conn->export->createTableSql($data['tableName'], $data['columns'], $data['options']);
-
-                $sql = array_merge($sql, (array) $query);
+            if (in_array($name, $finishedClasses)) {
+                continue;
             }
-
-            $data = $table->getExportableFormat();
-
+            
+            $classMetadata = $this->conn->getClassMetadata($name);
+            
+            // In Class Table Inheritance we have to make sure that ALL tables are exported
+            // as soon as ONE table is exported, because the data of one class is stored
+            // across many tables.
+            if ($classMetadata->getInheritanceType() == Doctrine::INHERITANCETYPE_JOINED) {
+                //echo "joined.<br />";
+                $parents = $classMetadata->getOption('parents');
+                foreach ($parents as $parent) {
+                    $data = $classMetadata->getConnection()->getClassMetadata($parent)->getExportableFormat();
+                    $query = $this->conn->export->createTableSql($data['tableName'], $data['columns'], $data['options']);
+                    $sql = array_merge($sql, (array) $query);
+                    $finishedClasses[] = $parent;
+                }
+            }
+            
+            $data = $classMetadata->getExportableFormat();
             $query = $this->conn->export->createTableSql($data['tableName'], $data['columns'], $data['options']);
 
             if (is_array($query)) {
@@ -1168,8 +1177,8 @@ class Doctrine_Export extends Doctrine_Connection_Module
                 $sql[] = $query;
             }
 
-            if ($table->getAttribute(Doctrine::ATTR_EXPORT) & Doctrine::EXPORT_PLUGINS) {
-                $sql = array_merge($sql, $this->exportGeneratorsSql($table));
+            if ($classMetadata->getAttribute(Doctrine::ATTR_EXPORT) & Doctrine::EXPORT_PLUGINS) {
+                $sql = array_merge($sql, $this->exportGeneratorsSql($classMetadata));
             }
         }
 
@@ -1185,8 +1194,9 @@ class Doctrine_Export extends Doctrine_Connection_Module
      *
      * @param Doctrine_Table $table     table object to retrieve the generators from
      * @return array                    an array of Doctrine_Record_Generator objects
+     * @todo package:orm
      */
-    public function getAllGenerators(Doctrine_Table $table)
+    public function getAllGenerators(Doctrine_ClassMetadata $table)
     {
         $generators = array();
 
@@ -1213,11 +1223,12 @@ class Doctrine_Export extends Doctrine_Connection_Module
      *
      * @param Doctrine_Table $table     the table in which the generators belong to
      * @return array                    an array of sql strings
+     * @todo package:orm
      */
-    public function exportGeneratorsSql(Doctrine_Table $table)
+    public function exportGeneratorsSql(Doctrine_ClassMetadata $class)
     {
     	$sql = array();
-        foreach ($this->getAllGenerators($table) as $name => $generator) {
+        foreach ($this->getAllGenerators($class) as $name => $generator) {
             $table = $generator->getTable();
 
             // Make sure plugin has a valid table

lib/Doctrine/Hydrator.php

@@ -60,16 +60,15 @@ class Doctrine_Hydrator extends Doctrine_Hydrator_Abstract
      */
     public function hydrateResultSet($stmt, $tableAliases, $hydrationMode = null)
     {
-        //$s = microtime(true);
-        $this->_tableAliases = $tableAliases;
+        if ($hydrationMode === null) {
+            $hydrationMode = $this->_hydrationMode;
+        }
         
         if ($hydrationMode == Doctrine::HYDRATE_NONE) {
             return $stmt->fetchAll(PDO::FETCH_NUM);
         }
         
-        if ($hydrationMode === null) {
-            $hydrationMode = $this->_hydrationMode;
-        }
+        $this->_tableAliases = $tableAliases;
 
         if ($hydrationMode === Doctrine::HYDRATE_ARRAY) {
             $driver = new Doctrine_Hydrator_ArrayDriver();
@@ -108,7 +107,7 @@ class Doctrine_Hydrator extends Doctrine_Hydrator_Abstract
         foreach ($this->_queryComponents as $dqlAlias => $data) {
             $data['mapper']->setAttribute(Doctrine::ATTR_LOAD_REFERENCES, false);
             $componentName = $data['mapper']->getComponentName();
-            $listeners[$componentName] = $data['table']->getRecordListener();
+            $listeners[$componentName] = $data['mapper']->getRecordListener();
             $identifierMap[$dqlAlias] = array();
             $prev[$dqlAlias] = array();
             $id[$dqlAlias] = '';

lib/Doctrine/Hydrator/ArrayDriver.php

@@ -20,8 +20,8 @@
  */
 
 /**
- * Doctrine_Hydrate_Array
- * defines an array fetching strategy for Doctrine_Hydrate
+ * Doctrine_Hydrator_ArrayDriver
+ * Defines an array fetching strategy.
  *
  * @package     Doctrine
  * @subpackage  Hydrate
@@ -33,47 +33,69 @@
  */
 class Doctrine_Hydrator_ArrayDriver
 {
+    /**
+     *
+     */
     public function getElementCollection($component)
     {
         return array();
     }
     
+    /**
+     *
+     */
     public function getElement(array $data, $component)
     {
         return $data;
     }
     
+    /** 
+     *
+     */
     public function isIdentifiable(array $data, Doctrine_Table $table)
     {
         return ( ! empty($data));
     }
     
+    /**
+     *
+     */
     public function registerCollection($coll)
-    {
-
-    }
+    { /* Nothing to do */ }
     
+    /**
+     *
+     */
     public function initRelated(array &$data, $name)
     {
         if ( ! isset($data[$name])) {
             $data[$name] = array();
         }
+        
         return true;
     }
     
+    /**
+     *
+     */
     public function getNullPointer() 
     {
         return null;    
     }
     
+    /**
+     *
+     */
     public function getLastKey(&$data)
     {
         end($data);
+        
         return key($data);
     }
-
+    
+    /**
+     *
+     */
     public function flush()
-    {
-        
-    }
+    { /* Nothing to do */ }
 }

lib/Doctrine/Hydrator/RecordDriver.php

@@ -104,11 +104,11 @@ class Doctrine_Hydrator_RecordDriver extends Doctrine_Locator_Injectable
     
     public function getElement(array $data, $component)
     {
+        $component = $this->_getClassnameToReturn($data, $component);
         if ( ! isset($this->_mappers[$component])) {
             $this->_mappers[$component] = Doctrine_Manager::getInstance()->getMapper($component);
         }
-        
-        $component = $this->_getClassnameToReturn($data, $component);
+
         $record = $this->_mappers[$component]->getRecord($data);
 
         if ( ! isset($this->_records[$record->getOid()]) ) {
@@ -128,35 +128,31 @@ class Doctrine_Hydrator_RecordDriver extends Doctrine_Locator_Injectable
     }
     
     /**
-     * Check the dataset for a discriminator column, to determine the correct
+     * Check the dataset for a discriminator column to determine the correct
      * class to instantiate. If no discriminator column is found, the given
      * classname will be returned.
      *
-     * @todo this function could use reflection to check the first time it runs
-     * if the subclassing option is not set.
-     *
      * @return string The name of the class to instantiate.
-     *
+     * @todo Can be optimized performance-wise.
      */
     protected function _getClassnameToReturn(array $data, $className)
     {
-        $subClasses = $this->_mappers[$className]->getTable()->getOption('subclasses');
-        if ( ! isset($subClasses)) {
+        if ( ! isset($this->_mappers[$className])) {
+            $this->_mappers[$className] = Doctrine_Manager::getInstance()->getMapper($className);
+        }
+        
+        $discCol = $this->_mappers[$className]->getTable()->getInheritanceOption('discriminatorColumn');
+        if ( ! $discCol) {
             return $className;
         }
-
-        foreach ($subClasses as $subclass) {
-            if ( ! isset($this->_mappers[$subclass])) {
-                $this->_mappers[$subclass] = Doctrine_Manager::getInstance()->getMapper($subclass);
-            }
-            $mapper = $this->_mappers[$subclass];
-            $inheritanceMap = $mapper->getDiscriminatorColumn();
-            foreach ($inheritanceMap as $key => $value) {
-                if (isset($data[$key]) && $data[$key] == $value) {
-                    return $mapper->getComponentName();
-                }
+        
+        $discMap = $this->_mappers[$className]->getTable()->getInheritanceOption('discriminatorMap');
+        foreach ($discMap as $value => $class) {
+            if (isset($data[$discCol]) && $data[$discCol] == $value) {
+                return $class;
             }
         }
+        
         return $className;
     }
 }

lib/Doctrine/Manager.php

@@ -64,6 +64,9 @@ class Doctrine_Manager extends Doctrine_Configurable implements Countable, Itera
      */
     protected $_queryRegistry;
 
+    /**
+     *
+     */
     protected static $driverMap = array('oci' => 'oracle');
 
     /**
@@ -476,6 +479,32 @@ class Doctrine_Manager extends Doctrine_Configurable implements Countable, Itera
 
         return $this->_connections[$name];
     }
+    
+    /**
+     * Creates a new Doctrine_Query object that uses the currently active connection.
+     * 
+     * @return Doctrine_Query 
+     */
+    public function createQuery($dql = "")
+    {
+        $query = new Doctrine_Query($this->getCurrentConnection());
+        if ( ! empty($dql)) {
+            $query->parseQuery($dql);
+        }
+        
+        return $query;
+    }
+    
+    /**
+     * Creates a query object out of a registered, named query.
+     *
+     * @param string $name     The name of the query.
+     * @return Doctrine_Query  The query object.
+     */
+    public function createNamedQuery($name)
+    {
+        return $this->_queryRegistry->get($name);
+    }
 
     /**
      * getComponentAlias

lib/Doctrine/Mapper/Joined.php

@@ -13,19 +13,19 @@ class Doctrine_Mapper_Joined extends Doctrine_Mapper_Abstract
      */
     protected function _doInsert(Doctrine_Record $record)
     {
-        $table = $this->_table;
+        $table = $this->_classMetadata;
                     
         $dataSet = $this->_formatDataSet($record);
-        $component = $table->getComponentName();
+        $component = $table->getClassName();
 
-        $classes = $table->getOption('joinedParents');
+        $classes = $table->getOption('parents');
         array_unshift($classes, $component);
         
         try {
             $this->_conn->beginInternalTransaction();
             $identifier = null;
             foreach (array_reverse($classes) as $k => $parent) {
-                $parentTable = $this->_conn->getTable($parent);
+                $parentTable = $this->_conn->getMetadata($parent);
                 if ($k == 0) {
                     $identifierType = $parentTable->getIdentifierType();
                     if ($identifierType == Doctrine::IDENTIFIER_AUTOINC) {
@@ -67,11 +67,11 @@ class Doctrine_Mapper_Joined extends Doctrine_Mapper_Abstract
      */
     protected function _doUpdate(Doctrine_Record $record)
     {
-        $table = $this->_table;
+        $table = $this->_classMetadata;
         $identifier = $record->identifier();                     
         $dataSet = $this->_formatDataSet($record);
-        $component = $table->getComponentName();
-        $classes = $table->getOption('joinedParents');
+        $component = $table->getClassName();
+        $classes = $table->getOption('parents');
         array_unshift($classes, $component);
 
         foreach ($record as $field => $value) {
@@ -84,7 +84,7 @@ class Doctrine_Mapper_Joined extends Doctrine_Mapper_Abstract
         }
 
         foreach (array_reverse($classes) as $class) {
-            $parentTable = $this->_conn->getTable($class);
+            $parentTable = $this->_conn->getMetadata($class);
             $this->_conn->update($parentTable, $dataSet[$class], $identifier);
         }
         
@@ -97,7 +97,7 @@ class Doctrine_Mapper_Joined extends Doctrine_Mapper_Abstract
     protected function _doDelete(Doctrine_Record $record, Doctrine_Connection $conn)
     {
         try {
-            $table = $this->_table;
+            $table = $this->_classMetadata;
             $conn->beginInternalTransaction();
             $this->deleteComposites($record);
 
@@ -128,10 +128,10 @@ class Doctrine_Mapper_Joined extends Doctrine_Mapper_Abstract
     public function getCustomJoins()
     {
         $customJoins = array();
-        foreach ($this->_table->getOption('joinedParents') as $parentClass) {
+        foreach ($this->_classMetadata->getOption('parents') as $parentClass) {
             $customJoins[$parentClass] = 'INNER';
         }
-        foreach ((array)$this->_table->getOption('subclasses') as $subClass) {
+        foreach ((array)$this->_classMetadata->getOption('subclasses') as $subClass) {
             if ($subClass != $this->_domainClassName) {
                 $customJoins[$subClass] = 'LEFT';
             }
@@ -141,10 +141,11 @@ class Doctrine_Mapper_Joined extends Doctrine_Mapper_Abstract
     
     public function getCustomFields()
     {
-        $fields = array();
-        if ($this->_table->getOption('subclasses')) {
-            foreach ($this->_table->getOption('subclasses') as $subClass) {
-                $fields = array_merge($this->_conn->getTable($subClass)->getFieldNames(), $fields);
+        $fields = array($this->_classMetadata->getInheritanceOption('discriminatorColumn'));
+        //$fields = array();
+        if ($this->_classMetadata->getOption('subclasses')) {
+            foreach ($this->_classMetadata->getOption('subclasses') as $subClass) {
+                $fields = array_merge($this->_conn->getMetadata($subClass)->getFieldNames(), $fields);
             }
         }
         return array_unique($fields);
@@ -155,9 +156,9 @@ class Doctrine_Mapper_Joined extends Doctrine_Mapper_Abstract
      */
     public function getDiscriminatorColumn()
     {
-        $joinedParents = $this->_table->getOption('joinedParents');
+        $joinedParents = $this->_classMetadata->getOption('joinedParents');
         if (count($joinedParents) <= 0) {
-            $inheritanceMap = $this->_table->getOption('inheritanceMap');
+            $inheritanceMap = $this->_classMetadata->getOption('inheritanceMap');
         } else {
             $inheritanceMap = $this->_conn->getTable(array_pop($joinedParents))->getOption('inheritanceMap');
         }
@@ -173,11 +174,7 @@ class Doctrine_Mapper_Joined extends Doctrine_Mapper_Abstract
             return $this->_fieldNames;
         }
         
-        $fieldNames = $this->_table->getFieldNames();
-        foreach ($this->_table->getOption('joinedParents') as $parent) {
-            $parentTable = $this->_conn->getTable($parent);
-            $fieldNames = array_merge($parentTable->getFieldNames(), $fieldNames);
-        }
+        $fieldNames = $this->_classMetadata->getFieldNames();
         $this->_fieldNames = array_unique($fieldNames);
         
         return $fieldNames;
@@ -189,46 +186,46 @@ class Doctrine_Mapper_Joined extends Doctrine_Mapper_Abstract
             return $this->_columnNameFieldNameMap[$columnName];
         }
         
-        if ($this->_table->hasColumn($columnName)) {
-            $this->_columnNameFieldNameMap[$columnName] = $this->_table->getFieldName($columnName);
+        if ($this->_classMetadata->hasColumn($columnName)) {
+            $this->_columnNameFieldNameMap[$columnName] = $this->_classMetadata->getFieldName($columnName);
             return $this->_columnNameFieldNameMap[$columnName];
         }
         
-        foreach ($this->_table->getOption('joinedParents') as $parentClass) {
-            $parentTable = $this->_conn->getTable($parentClass);
+        foreach ($this->_classMetadata->getOption('parents') as $parentClass) {
+            $parentTable = $this->_conn->getMetadata($parentClass);
             if ($parentTable->hasColumn($columnName)) {
                 $this->_columnNameFieldNameMap[$columnName] = $parentTable->getFieldName($columnName);
                 return $this->_columnNameFieldNameMap[$columnName];
             }
         }
         
-        foreach ((array)$this->_table->getOption('subclasses') as $subClass) {
-            $subTable = $this->_conn->getTable($subClass);
+        foreach ((array)$this->_classMetadata->getOption('subclasses') as $subClass) {
+            $subTable = $this->_conn->getMetadata($subClass);
             if ($subTable->hasColumn($columnName)) {
                 $this->_columnNameFieldNameMap[$columnName] = $subTable->getFieldName($columnName);
                 return $this->_columnNameFieldNameMap[$columnName];
             }
         }
-        
+
         throw new Doctrine_Mapper_Exception("No field name found for column name '$columnName'.");
     }
     
     public function getOwningTable($fieldName)
-    {
-        if ($this->_table->hasField($fieldName)) {
-            return $this->_table;
+    {        
+        if ($this->_classMetadata->hasField($fieldName) && ! $this->_classMetadata->isInheritedField($fieldName)) {
+            return $this->_classMetadata;
         }
         
-        foreach ($this->_table->getOption('joinedParents') as $parentClass) {
-            $parentTable = $this->_conn->getTable($parentClass);
-            if ($parentTable->hasField($fieldName)) {
+        foreach ($this->_classMetadata->getOption('parents') as $parentClass) {
+            $parentTable = $this->_conn->getMetadata($parentClass);
+            if ($parentTable->hasField($fieldName) && ! $parentTable->isInheritedField($fieldName)) {
                 return $parentTable;
             }
         }
         
-        foreach ((array)$this->_table->getOption('subclasses') as $subClass) {
-            $subTable = $this->_conn->getTable($subClass);
-            if ($subTable->hasField($fieldName)) {
+        foreach ((array)$this->_classMetadata->getOption('subclasses') as $subClass) {
+            $subTable = $this->_conn->getMetadata($subClass);
+            if ($subTable->hasField($fieldName) && ! $subTable->isInheritedField($fieldName)) {
                 return $subTable;
             }
         }
@@ -241,17 +238,18 @@ class Doctrine_Mapper_Joined extends Doctrine_Mapper_Abstract
      */
     protected function _formatDataSet(Doctrine_Record $record)
     {
-        $table = $this->_table;
+        $table = $this->_classMetadata;
         $dataSet = array();
-        $component = $table->getComponentName();
+        $component = $table->getClassName();
         $array = $record->getPrepared();
         
-        $classes = array_merge(array($component), $this->_table->getOption('joinedParents'));
+        $classes = array_merge(array($component), $this->_classMetadata->getParentClasses());
         
         foreach ($classes as $class) {
-            $table = $this->_conn->getTable($class);
-            foreach ($table->getColumns() as $columnName => $definition) {
-                if (isset($definition['primary'])) {
+            $metadata = $this->_conn->getMetadata($class);
+            foreach ($metadata->getColumns() as $columnName => $definition) {
+                if ((isset($definition['primary']) && $definition['primary'] === true) ||
+                        (isset($definition['inherited']) && $definition['inherited'] === true)) {
                     continue;
                 }
                 $fieldName = $table->getFieldName($columnName);

lib/Doctrine/Mapper/SingleTable.php

@@ -5,7 +5,7 @@ class Doctrine_Mapper_SingleTable extends Doctrine_Mapper_Abstract
     
     public function getDiscriminatorColumn()
     {
-        $inheritanceMap = $this->_table->getOption('inheritanceMap');
+        $inheritanceMap = $this->_classMetadata->getOption('inheritanceMap');
         return isset($inheritanceMap[$this->_domainClassName]) ? $inheritanceMap[$this->_domainClassName] : array();
     }
     

lib/Doctrine/Node/NestedSet.php

@@ -302,8 +302,10 @@ class Doctrine_Node_NestedSet extends Doctrine_Node implements Doctrine_Node_Int
     {
         $path = array();
         $ancestors = $this->getAncestors();
-        foreach ($ancestors as $ancestor) {
-            $path[] = $ancestor->__toString();
+        if ($ancestors) {
+            foreach ($ancestors as $ancestor) {
+                $path[] = $ancestor->__toString();
+            }
         }
         if ($includeRecord) {
             $path[] = $this->getRecord()->__toString();

lib/Doctrine/Query.php

@@ -1620,7 +1620,7 @@ class Doctrine_Query extends Doctrine_Query_Abstract implements Countable, Seria
             $this->_conn = $manager->getConnectionForComponent($name);
         }
 
-        $table = $this->_conn->getTable($name);
+        $table = $this->_conn->getMetadata($name);
         $tableName = $table->getTableName();
 
         // get the short alias for this table

lib/Doctrine/Query/Abstract.php

@@ -528,12 +528,12 @@ abstract class Doctrine_Query_Abstract
      */
     protected function _createCustomJoinSql($componentName, $componentAlias)
     {
-        $table = $this->_conn->getTable($componentName);
+        $table = $this->_conn->getMetadata($componentName);
         $tableAlias = $this->getSqlTableAlias($componentAlias, $table->getTableName());
         $customJoins = $this->_conn->getMapper($componentName)->getCustomJoins();
         $sql = '';
         foreach ($customJoins as $componentName => $joinType) {
-            $joinedTable = $this->_conn->getTable($componentName);
+            $joinedTable = $this->_conn->getMetadata($componentName);
             $joinedAlias = $componentAlias . '.' . $componentName;
             $joinedTableAlias = $this->getSqlTableAlias($joinedAlias, $joinedTable->getTableName());
             $sql .= " $joinType JOIN " . $this->_conn->quoteIdentifier($joinedTable->getTableName())
@@ -553,6 +553,7 @@ abstract class Doctrine_Query_Abstract
     /**
      * Creates the SQL snippet for the WHERE part that contains the discriminator
      * column conditions.
+     * Used solely for Single Table Inheritance.
      *
      * @return string  The created SQL snippet.
      */
@@ -564,7 +565,25 @@ abstract class Doctrine_Query_Abstract
             if ( ! $data['mapper'] instanceof Doctrine_Mapper_SingleTable) {
                 $array[$sqlTableAlias][] = array();
             } else {
-                $array[$sqlTableAlias][] = $data['mapper']->getDiscriminatorColumn();
+                $discCol = $data['table']->getInheritanceOption('discriminatorColumn');
+                $discMap = $data['table']->getInheritanceOption('discriminatorMap');
+                $discValue = array_search($data['table']->getClassName(), $discMap);
+                if ($discValue === false) {
+                    continue;
+                }
+                $discriminator = array();
+                $discriminator[] = array($discCol => $discValue);
+                
+                $subclasses = $data['table']->getSubclasses();
+                foreach ((array)$subclasses as $subclass) {
+                    $subClassMetadata = $this->_conn->getClassMetadata($subclass);
+                    $discCol = $subClassMetadata->getInheritanceOption('discriminatorColumn');
+                    $discMap = $subClassMetadata->getInheritanceOption('discriminatorMap');
+                    $discValue = array_search($subclass, $discMap);
+                    $discriminator[] = array($discCol => $discValue);
+                }
+                
+                $array[$sqlTableAlias][] = $discriminator;
             }
         }
         //var_dump($array);
@@ -584,10 +603,11 @@ abstract class Doctrine_Query_Abstract
             }
 
             foreach ($maps as $map) {
+                //echo "start";
                 $b = array();
-                foreach ($map as $field => $value) {
-                    $identifier = $this->_conn->quoteIdentifier($tableAlias . $field);
-
+                foreach ($map as $discriminator) {
+                    list($column, $value) = each($discriminator);
+                    $identifier = $this->_conn->quoteIdentifier($tableAlias . $column);
                     if ($index > 0) {
                         $b[] = '(' . $identifier . ' = ' . $this->_conn->quote($value)
                              . ' OR ' . $identifier . ' IS NULL)';
@@ -597,10 +617,14 @@ abstract class Doctrine_Query_Abstract
                 }
 
                 if ( ! empty($b)) {
-                    $a[] = implode(' AND ', $b);
+                    if (count($b) > 1) {
+                        $a[] = '(' . implode(' OR ', $b) . ')';
+                    } else {
+                        $a[] = implode(' OR ', $b);
+                    }                    
                 }
             }
-
+            //echo "end<br />";
             if ( ! empty($a)) {
                 $c[] = implode(' AND ', $a);
             }

lib/Doctrine/Query/Check.php

@@ -53,7 +53,7 @@ class Doctrine_Query_Check
         if ( ! ($table instanceof Doctrine_Table)) {
             $table = Doctrine_Manager::getInstance()
                         ->getCurrentConnection()
-                        ->getTable($table);
+                        ->getClassMetadata($table);
         }
         $this->table = $table;
         $this->_tokenizer = new Doctrine_Query_Tokenizer();

lib/Doctrine/Query/Where.php

@@ -86,7 +86,7 @@ class Doctrine_Query_Where extends Doctrine_Query_Condition
         }
     }
 
-    public function parseValue($value, Doctrine_Table $table = null, $field = null)
+    public function parseValue($value, $table = null, $field = null)
     {
         $conn = $this->query->getConnection();
 

lib/Doctrine/RawSql.php

@@ -81,6 +81,7 @@ class Doctrine_RawSql extends Doctrine_Query_Abstract
         } else {
             $this->_sqlParts[$queryPartName][] = $queryPart;
         }
+        
         return $this;
     }
 
@@ -316,7 +317,7 @@ class Doctrine_RawSql extends Doctrine_Query_Abstract
                 $conn = Doctrine_Manager::getInstance()
                         ->getConnectionForComponent($component);
 
-                $table = $conn->getTable($component);
+                $table = $conn->getClassMetadata($component);
                 $this->_queryComponents[$componentAlias] = array(
                         'table' => $table, 'mapper' => $conn->getMapper($component));
             } else {
@@ -324,7 +325,7 @@ class Doctrine_RawSql extends Doctrine_Query_Abstract
 
                 $this->_queryComponents[$componentAlias] = array(
                         'table'    => $relation->getTable(),
-                        'mapper' => $this->_conn->getMapper($component),
+                        'mapper'   => $this->_conn->getMapper($component),
                         'parent'   => $parent,
                         'relation' => $relation);
             }

lib/Doctrine/Record/Abstract.php

@@ -42,16 +42,21 @@ abstract class Doctrine_Record_Abstract extends Doctrine_Access
      * @var Doctrine_Mapper_Abstract
      */
     protected $_mapper;
-
+    
+    /**
+     * @deprecated
+     */
     public function setTableDefinition()
-    {
-    	
-    }
+    {}
     
+    /**
+     * @deprecated
+     */
     public function setUp()
-    {
-    	
-    }	
+    {}	
+
+    public static function initMapping(Doctrine_MetadataClass $class)
+    {}
 
 
     /**
@@ -65,6 +70,9 @@ abstract class Doctrine_Record_Abstract extends Doctrine_Access
         return $this->_table;
     }
     
+    /**
+     * Returns the mapper of the entity.
+     */
     public function getMapper()
     {
         return $this->_mapper;
@@ -105,6 +113,43 @@ abstract class Doctrine_Record_Abstract extends Doctrine_Access
 
         return $this;
     }
+    
+    public function setAttribute($attr, $value)
+    {
+        $this->_table->setAttribute($attr, $value);
+    }
+    
+    /**
+     * attribute
+     * sets or retrieves an option
+     *
+     * @see Doctrine::ATTR_* constants   availible attributes
+     * @param mixed $attr
+     * @param mixed $value
+     * @return mixed
+     */
+    public function attribute($attr, $value)
+    {
+        if ($value == null) {
+            if (is_array($attr)) {
+                foreach ($attr as $k => $v) {
+                    $this->_table->setAttribute($k, $v);
+                }
+            } else {
+                return $this->_table->getAttribute($attr);
+            }
+        } else {
+            $this->_table->setAttribute($attr, $value);
+        }    
+    }
+
+    
+    /* THE FOLLOWING STUFF WILL ALL BE REMOVED SOON */
+
+    public function setTableName($tableName)
+    {
+        $this->_table->setTableName($tableName);
+    }
 
     /**
      * index
@@ -124,14 +169,6 @@ abstract class Doctrine_Record_Abstract extends Doctrine_Access
             return $this->_table->addIndex($name, $definition);
         }
     }
-    public function setAttribute($attr, $value)
-    {
-        $this->_table->setAttribute($attr, $value);
-    }
-    public function setTableName($tableName)
-    {
-        $this->_table->setTableName($tableName);
-    }
     
     /**
      *
@@ -150,30 +187,6 @@ abstract class Doctrine_Record_Abstract extends Doctrine_Access
         $this->_table->setInheritanceType(Doctrine::INHERITANCETYPE_SINGLE_TABLE);
     }
 
-    /**
-     * attribute
-     * sets or retrieves an option
-     *
-     * @see Doctrine::ATTR_* constants   availible attributes
-     * @param mixed $attr
-     * @param mixed $value
-     * @return mixed
-     */
-    public function attribute($attr, $value)
-    {
-        if ($value == null) {
-            if (is_array($attr)) {
-                foreach ($attr as $k => $v) {
-                    $this->_table->setAttribute($k, $v);
-                }
-            } else {
-                return $this->_table->getAttribute($attr);
-            }
-        } else {
-            $this->_table->setAttribute($attr, $value);
-        }    
-    }
-
     /**
      * option
      * sets or retrieves an option
@@ -282,7 +295,7 @@ abstract class Doctrine_Record_Abstract extends Doctrine_Access
     {
         $this->_table->setColumn($name, $type, $length, $options);
     }
-
+    
     /**
      * hasColumns
      *
@@ -389,11 +402,6 @@ abstract class Doctrine_Record_Abstract extends Doctrine_Access
         }
         $this->_table->setInheritanceType($type);
     }
-    
-    protected function _getMapper($className)
-    {
-        
-    }
 
     /**
      * check

lib/Doctrine/Record/Filter.php

@@ -35,7 +35,7 @@ abstract class Doctrine_Record_Filter
 {
     protected $_table;
 
-    public function setTable(Doctrine_Table $table)
+    public function setTable(Doctrine_ClassMetadata $table)
     {
         $this->_table = $table;
     }

lib/Doctrine/Record/Generator.php

@@ -111,7 +111,7 @@ abstract class Doctrine_Record_Generator extends Doctrine_Record_Abstract
         return $this->_options;
     }
 
-    public function initialize(Doctrine_Table $table)
+    public function initialize($table)
     {
     	if ($this->_initialized) {
     	    return false;
@@ -188,7 +188,7 @@ abstract class Doctrine_Record_Generator extends Doctrine_Record_Abstract
      * @param Doctrine_Table $table     the table object that owns the plugin
      * @return array                    an array of foreign key definitions
      */
-    public function buildForeignKeys(Doctrine_Table $table)
+    public function buildForeignKeys($table)
     {
         $fk = array();
 

lib/Doctrine/Relation.php

@@ -143,6 +143,11 @@ abstract class Doctrine_Relation implements ArrayAccess
         $def = array();
         foreach ($this->definition as $key => $val) {
             if ( ! isset($definition[$key]) && $val) {
+                try {
+                    throw new Exception();
+                } catch (Exception $e) {
+                    echo $e->getTraceAsString() . "<br />";
+                }
                 throw new Doctrine_Exception($key . ' is required!');
             }
             if (isset($definition[$key])) {
@@ -257,7 +262,7 @@ abstract class Doctrine_Relation implements ArrayAccess
     {
         return Doctrine_Manager::getInstance()
                ->getConnectionForComponent($this->definition['class'])
-               ->getTable($this->definition['class']);
+               ->getMetadata($this->definition['class']);
     }
 
     /**

lib/Doctrine/Relation/Association.php

@@ -61,19 +61,7 @@ class Doctrine_Relation_Association extends Doctrine_Relation
     public function getRelationDql($count, $context = 'record')
     {
         //$table = $this->definition['refTable'];
-        $assocRelationName = isset($this->definition['refReverseRelationName']) ?
-                $this->definition['refReverseRelationName'] : $this->definition['refClass'];
-
-        /*if ($this->definition['localTable'] === $this->definition['table']) {
-            echo $this->definition['class'];
-            $rel = $this->definition['table']->getRelation('User');
-            $relationName = $rel->getRelationName();
-        }*/   
-               
-        //var_dump($this->definition['foreign']) . "<br />";
-        //echo $component;
-        //$rel = $this->definition['refTable']->getRelation($this->_foreignMapper->getComponentName());
-        //echo "LOCAL:" . $rel->getLocal() . "<br />";
+        $assocRelationName = $this->definition['refClass'];
         
         $relatedClassName = $this->_foreignMapper->getComponentName();
         

lib/Doctrine/Relation/Parser.php

@@ -53,7 +53,7 @@ class Doctrine_Relation_Parser
      *
      * @param Doctrine_Table $table         the table object this parser belongs to
      */
-    public function __construct(Doctrine_Table $table) 
+    public function __construct(/*Doctrine_Table*/ $table) 
     {
         $this->_table = $table;
     }
@@ -100,8 +100,8 @@ class Doctrine_Relation_Parser
      */
     public function bind($name, $options = array())
     {
-        if (isset($this->relations[$name])) {
-            unset($this->relations[$name]);
+        if (isset($this->_relations[$name])) {
+            unset($this->_relations[$name]);
         }
 
         $e = explode(' as ', $name);
@@ -111,7 +111,7 @@ class Doctrine_Relation_Parser
         if ( ! isset($options['type'])) {
             throw new Doctrine_Relation_Exception('Relation type not set.');
         }
-
+        
         $this->_pending[$alias] = array_merge($options, array('class' => $name, 'alias' => $alias));
 
         return $this->_pending[$alias];
@@ -125,9 +125,6 @@ class Doctrine_Relation_Parser
     public function getRelation($alias, $recursive = true)
     {
         if (isset($this->_relations[$alias])) {
-            /*if ($alias == 'Groupuser') {
-                //var_dump($this->_relations[$alias]['foreign']);
-            }*/
             return $this->_relations[$alias];
         }
 
@@ -139,14 +136,22 @@ class Doctrine_Relation_Parser
             $this->getRelations();
             return $this->getRelation($alias, false);
         } else {
-            /*try {
-                throw new Doctrine_Table_Exception('Unknown relation alias ' . $alias);
+            try {
+                throw new Exception();
             } catch (Exception $e) {
-                echo $e->getTraceAsString();
-                echo "<br /><br />";
-            }*/
-            throw new Doctrine_Table_Exception('Unknown relation alias ' . $alias);
+                //echo "" . "<br />";
+                ///echo $e->getTraceAsString() . "<br /><br /><br />";
+            }
+            throw new Doctrine_Relation_Exception("Unknown relation '$alias'.");
+        }
+    }
+    
+    public function addRelation($name, Doctrine_Relation $relation)
+    {
+        if (isset($this->_relations[$name])) {
+            throw new Doctrine_Relation_Exception("Relation '$name' does already exist.");
         }
+        $this->_relations[$name] = $relation;
     }
     
     /**
@@ -164,11 +169,11 @@ class Doctrine_Relation_Parser
         // if it does we are dealing with an association relation (many-many)
         if (isset($def['refClass'])) {
             $def = $this->completeAssocDefinition($def);
-            $localClasses = array_merge($this->_table->getOption('parents'), array($this->_table->getComponentName()));
+            $localClasses = array_merge($this->_table->getOption('parents'), array($this->_table->getClassName()));
 
             // if the two many-many related components share the same table, we need
             // custom relation names to distinguish the relations.
-            if ($this->_table->getInheritanceType() == Doctrine::INHERITANCETYPE_SINGLE_TABLE &&
+            /*if ($this->_table->getInheritanceType() == Doctrine::INHERITANCETYPE_SINGLE_TABLE &&
                     in_array($def['class'], $this->_table->getOption('subclasses'))) {
                 if ( ! isset($def['refRelationName']) || ! isset($def['refReverseRelationName'])) {
                     throw new Doctrine_Relation_Exception("Incomplete relation. Many-to-many relations between "
@@ -176,9 +181,9 @@ class Doctrine_Relation_Parser
                             . "a 'refRelationName' and a 'refReverseRelationName' to distinguish relations.");
                 }            
                 $relationName = $def['refRelationName'];
-            } else {
+            } else {*/
                 $relationName = $def['refClass'];
-            }
+            //}
 
             if ( ! isset($this->_pending[$relationName]) && ! isset($this->_relations[$relationName])) {
                 $this->_completeManyToManyRelation($def);
@@ -220,14 +225,14 @@ class Doctrine_Relation_Parser
         // if the two many-many related components shared the same table, we need a relation name
         // to distinguish the relations.
         $relationName = $def['refClass'];
-        if (isset($def['refRelationName'])) {
+        /*if (isset($def['refRelationName'])) {
            $relationName .= ' as ' . $def['refRelationName'];
-        }
+        }*/
         
         // add a relation pointing from the intermediary table to the table of this parser
         $parser = $def['refTable']->getRelationParser();
-        if ( ! $parser->hasRelation($this->_table->getComponentName())) {
-            $parser->bind($this->_table->getComponentName(),
+        if ( ! $parser->hasRelation($this->_table->getClassName())) {
+            $parser->bind($this->_table->getClassName(),
                     array('type'    => Doctrine_Relation::ONE,
                           'local'   => $def['local'],
                           'foreign' => $idColumnName,
@@ -280,7 +285,7 @@ class Doctrine_Relation_Parser
             $def[$key] = $impl;
         }
 
-        return $conn->getTable($def[$key]);
+        return $conn->getMetadata($def[$key]);
     }
     
     protected function _isTemplate($className)
@@ -345,7 +350,7 @@ class Doctrine_Relation_Parser
      *
      * @param Doctrine_Table $table     table object to retrieve identifiers from
      */
-    public function getIdentifiers(Doctrine_Table $table)
+    public function getIdentifiers($table)
     {
         $componentNameToLower = strtolower($table->getComponentName());
         if (is_array($table->getIdentifier())) {
@@ -368,13 +373,13 @@ class Doctrine_Relation_Parser
      * @param Doctrine_Table $foreignTable      foreign table object
      * @return array                            an array of column names
      */
-    public function guessColumns(array $classes, Doctrine_Table $foreignTable)
+    public function guessColumns(array $classes, $foreignTable)
     {
         $conn = $this->_table->getConnection();
 
         foreach ($classes as $class) {
             try {
-                $table   = $conn->getTable($class);
+                $table = $conn->getClassMetadata($class);
             } catch (Doctrine_Table_Exception $e) {
                 continue;
             }
@@ -415,9 +420,18 @@ class Doctrine_Relation_Parser
         $def['localTable'] = $this->_table;
 
         $foreignClasses = array_merge($def['table']->getOption('parents'), array($def['class']));
-        $localClasses   = array_merge($this->_table->getOption('parents'), array($this->_table->getComponentName()));
+        $localClasses   = array_merge($this->_table->getOption('parents'), array($this->_table->getClassName()));
 
         $localIdentifierColumnNames = $this->_table->getIdentifierColumnNames();
+        if ((count($localIdentifierColumnNames) - 1) < 0) {
+            echo $this->_table->getClassName();
+            var_dump($this->_table->getIdentifier());
+            try {
+                throw new Exception();
+            } catch (Exception $e) {
+                echo $e->getTraceAsString() . "<br />";
+            }
+        }
         $localIdColumnName = $localIdentifierColumnNames[count($localIdentifierColumnNames) - 1];
         $foreignIdentifierColumnNames = $def['table']->getIdentifierColumnNames();
         $foreignIdColumnName = $foreignIdentifierColumnNames[count($foreignIdentifierColumnNames) - 1];
@@ -462,14 +476,14 @@ class Doctrine_Relation_Parser
 
                 // the following loops are needed for covering inheritance
                 foreach ($localClasses as $class) {
-                    $table = $conn->getTable($class);
+                    $table = $conn->getClassMetadata($class);
                     $identifierColumnNames = $table->getIdentifierColumnNames();
                     $idColumnName = array_pop($identifierColumnNames);
                     $column = strtolower($table->getComponentName())
                             . '_' . $idColumnName;
 
                     foreach ($foreignClasses as $class2) {
-                        $table2 = $conn->getTable($class2);
+                        $table2 = $conn->getClassMetadata($class2);
                         if ($table2->hasColumn($column)) {
                             $def['foreign'] = $column;
                             $def['local'] = $idColumnName;
@@ -479,14 +493,14 @@ class Doctrine_Relation_Parser
                 }
 
                 foreach ($foreignClasses as $class) {
-                    $table  = $conn->getTable($class);
+                    $table  = $conn->getClassMetadata($class);
                     $identifierColumnNames = $table->getIdentifierColumnNames();
                     $idColumnName = array_pop($identifierColumnNames);
                     $column = strtolower($table->getComponentName())
                             . '_' . $idColumnName;
                 
                     foreach ($localClasses as $class2) {
-                        $table2 = $conn->getTable($class2);
+                        $table2 = $conn->getClassMetadata($class2);
                         if ($table2->hasColumn($column)) {
                             $def['foreign']  = $idColumnName;
                             $def['local']    = $column;

lib/Doctrine/Table/Factory.php

@@ -27,7 +27,7 @@ class Doctrine_Table_Factory
      * @param array  $tables The metadata collection to which the loaded metadata is added.
      */
     public function loadTables($name, array &$tables)
-    {
+    {        
         $parentClass = $name;
         $parentClasses = array();
         $parentClassWithTable = false;
@@ -104,13 +104,6 @@ class Doctrine_Table_Factory
         }
     }
     
-    
-    protected function _createTable($domainClassName)
-    {        
-        return $this->_loadMetaDataFromCode($table, $domainClassName);
-        
-    }
-    
     /**
      * Initializes the in-memory metadata for the domain class this mapper belongs to.
      * Uses reflection and code setup.
@@ -187,11 +180,12 @@ class Doctrine_Table_Factory
                             $joinedParents[] = $parentColumns[$columnName]['owner'];*/
                             $joinedParents[] = $parentTable->getComponentName();
                         }
-                    } else {
+                    }/* else {
+                        //echo "adding primary key $columnName on ".$table->getComponentName().".<br />";
                         unset($definition['autoincrement']);
                         $fullName = $columnName . ' as ' . $parentTable->getFieldName($columnName);
                         $table->setColumn($fullName, $definition['type'], $definition['length'], $definition, true);
-                    }
+                    }*/
                 }
             }
             $table->setOption('joinedParents', array_values(array_unique($joinedParents)));
@@ -289,7 +283,7 @@ class Doctrine_Table_Factory
                         unset($definition['sequence']);
 
                         // add the inherited primary key column
-                        $fullName = $id . ' as ' . $rootTable->getFieldName($id);
+                        $fullName = $rootTable->getColumnName($id) . ' as ' . $id;
                         $table->setColumn($fullName, $definition['type'], $definition['length'],
                                 $definition, true);
                     }

lib/Doctrine/Template.php

@@ -45,7 +45,7 @@ class Doctrine_Template extends Doctrine_Record_Abstract
      *
      * @param Doctrine_Table $_table        the table object this Template belongs to
      */
-    public function setTable(Doctrine_Table $table)
+    public function setTable($table)
     {
         $this->_table = $table;
     }

lib/Doctrine/Tree.php

@@ -49,7 +49,7 @@ class Doctrine_Tree
      * @param object $table                     instance of Doctrine_Table
      * @param array $options                    options
      */
-    public function __construct(Doctrine_Table $table, $options)
+    public function __construct($table, $options)
     {
         $this->table = $table;
         $this->options = $options;
@@ -92,7 +92,7 @@ class Doctrine_Tree
      * @return object $options                  instance of Doctrine_Node
      * @throws Doctrine_Exception               if class does not extend Doctrine_Tree
      */
-    public static function factory(Doctrine_Table $table, $implName, $options = array())
+    public static function factory($table, $implName, $options = array())
     {
         $class = 'Doctrine_Tree_' . $implName;
         if ( ! class_exists($class)) {

lib/Doctrine/Tree/NestedSet.php

@@ -41,7 +41,7 @@ class Doctrine_Tree_NestedSet extends Doctrine_Tree implements Doctrine_Tree_Int
      * @param object $table                     instance of Doctrine_Table
      * @param array $options                    options
      */
-    public function __construct(Doctrine_Table $table, $options)
+    public function __construct($table, $options)
     {
         // set default many root attributes
         $options['hasManyRoots'] = isset($options['hasManyRoots']) ? $options['hasManyRoots'] : false;

lib/Doctrine/Validator.php

@@ -21,7 +21,7 @@
 
 /**
  * Doctrine_Validator
- * Doctrine_Validator performs validations in record properties
+ * Doctrine_Validator performs validations on record properties
  *
  * @package     Doctrine
  * @subpackage  Validator
@@ -105,14 +105,15 @@ class Doctrine_Validator extends Doctrine_Locator_Injectable
 
             foreach ($column as $name => $args) {
                 if (empty($name)
-                    || $name == 'primary'
-                    || $name == 'protected'
-                    || $name == 'autoincrement'
-                    || $name == 'default'
-                    || $name == 'values'
-                    || $name == 'sequence'
-                    || $name == 'zerofill'
-                    || $name == 'scale') {
+                        || $name == 'primary'
+                        || $name == 'protected'
+                        || $name == 'autoincrement'
+                        || $name == 'default'
+                        || $name == 'values'
+                        || $name == 'sequence'
+                        || $name == 'zerofill'
+                        || $name == 'scale'
+                        || $name == 'inherited') {
                     continue;
                 }
 

models/Account.php

 <?php
 class Account extends Doctrine_Record 
 {
-    public function setTableDefinition() 
+    public static function initMetadata($class) 
     {
-        $this->hasColumn('entity_id', 'integer');
-        $this->hasColumn('amount', 'integer');
+        $class->setColumn('entity_id', 'integer');
+        $class->setColumn('amount', 'integer');
     }
 }
 

models/Address.php

 <?php
 class Address extends Doctrine_Record 
 {
-    public function setUp()
+    public static function initMetadata($class)
     {
-        $this->hasMany('User', array('local' => 'address_id', 
+        $class->setColumn('address', 'string', 200);
+        $class->hasMany('User', array('local' => 'address_id', 
                                      'foreign' => 'user_id',
                                      'refClass' => 'EntityAddress'));
     }
-    public function setTableDefinition() {
-        $this->hasColumn('address', 'string', 200);
-    }
 }

models/Album.php

 <?php
 class Album extends Doctrine_Record
 {
-    public function setUp()
+    public static function initMetadata($class)
     {
-        $this->hasMany('Song', array('local' => 'id', 'foreign' => 'album_id'));
-        $this->hasOne('User', array('local' => 'user_id',
+        $class->setColumn('user_id', 'integer');
+        $class->setColumn('name', 'string',20);
+        $class->hasMany('Song', array('local' => 'id', 'foreign' => 'album_id'));
+        $class->hasOne('User', array('local' => 'user_id',
                                     'foreign' => 'id',
                                     'onDelete' => 'CASCADE'));
     }
-    public function setTableDefinition()
-    {
-        $this->hasColumn('user_id', 'integer');
-        $this->hasColumn('name', 'string',20);
-    }
 }
 

models/App.php

 <?php
 class App extends Doctrine_Record {
-    public function setTableDefinition() {
-        $this->hasColumn('name', 'string', 32);
-        $this->hasColumn('user_id', 'integer', 11);
-        $this->hasColumn('app_category_id', 'integer', 11);
-    }
-    public function setUp() {
-        $this->hasOne('User', 'User.id');
-        $this->hasMany('App_Category as Category', 'App_Category.id');
-    }        
+    public static function initMetadata($class) {
+        $class->setColumn('name', 'string', 32);
+        $class->setColumn('user_id', 'integer', 11);
+        $class->setColumn('app_category_id', 'integer', 11);
+        $class->hasOne('User', array('local' => 'user_id', 'foreign' => 'id'));
+        $class->hasOne('App_Category as Category', array('local' => 'app_category_id', 'foreign' => 'id'));
+    }     
 }
 

models/App_Category.php

 <?php
 class App_Category extends Doctrine_Record {
-    public function setTableDefinition() {
-        $this->hasColumn('name', 'string', 32);
-        $this->hasColumn('parent_id', 'integer');
-    }
-    public function setUp() {
-        $this->hasMany('App', 'App.app_category_id');
-        $this->hasMany('App_Category as Parent', 'App_Category.parent_id');
+    public static function initMetadata($class) {
+        $class->setColumn('name', 'string', 32);
+        $class->setColumn('parent_id', 'integer');
+        $class->hasMany('App', array('local' => 'id', 'foreign' => 'app_category_id'));
+        $class->hasOne('App_Category as Parent', array('local' => 'parent_id', 'foreign' => 'id'));
     }
 }

models/App_User.php

 <?php
 class App_User extends Doctrine_Record {
-    public function setTableDefinition() {
-        $this->hasColumn('first_name', 'string', 32);
-        $this->hasColumn('last_name', 'string', 32);
-        $this->hasColumn('email', 'string', 128, 'email');
-        $this->hasColumn('username', 'string', 16, 'unique, nospace');
-        $this->hasColumn('password', 'string', 128, 'notblank');
-        $this->hasColumn('country', 'string', 2, 'country');
-        $this->hasColumn('zipcode', 'string', 9, 'nospace');
+    public static function initMetadata($class) {
+        $class->setColumn('first_name', 'string', 32);
+        $class->setColumn('last_name', 'string', 32);
+        $class->setColumn('email', 'string', 128, 'email');
+        $class->setColumn('username', 'string', 16, 'unique, nospace');
+        $class->setColumn('password', 'string', 128, 'notblank');
+        $class->setColumn('country', 'string', 2, 'country');
+        $class->setColumn('zipcode', 'string', 9, 'nospace');
+        $class->hasMany('App', array('local' => 'id', 'foreign' => 'user_id'));
     }
-    public function setUp() {
-        $this->hasMany('App', 'App.user_id');
-    }    
 }

models/Assignment.php

 <?php
 class Assignment extends Doctrine_Record {
-    public function setTableDefinition() {
-       $this->hasColumn('task_id', 'integer'); 
-       $this->hasColumn('resource_id', 'integer'); 
+    public static function initMetadata($class) {
+       $class->setColumn('task_id', 'integer'); 
+       $class->setColumn('resource_id', 'integer'); 
     } 
 }
 

models/Auth.php

 <?php
 class Auth extends Doctrine_Record 
 {
-    public function setTableDefinition() 
+    public static function initMetadata($class) 
     {
-        $this->hasColumn('roleid', 'integer', 10);
-        $this->hasColumn('name', 'string', 50);
-    }
-    public function setUp() 
-    {
-        $this->hasOne('Role', array('local' => 'roleid', 'foreign' => 'id'));
+        $class->setColumn('roleid', 'integer', 10);
+        $class->setColumn('name', 'string', 50);
+        $class->hasOne('Role', array('local' => 'roleid', 'foreign' => 'id'));
     }
 }
 

models/Author.php

 <?php
 class Author extends Doctrine_Record
 {
-    public function setUp()
+    public static function initMetadata($class)
     {
-        $this->hasOne('Book', array('local' => 'book_id',
+        $class->setColumn('book_id', 'integer');
+        $class->setColumn('name', 'string',20);
+        $class->hasOne('Book', array('local' => 'book_id',
                                     'foreign' => 'id',
                                     'onDelete' => 'CASCADE'));
     }
-    public function setTableDefinition()
-    {
-        $this->hasColumn('book_id', 'integer');
-        $this->hasColumn('name', 'string',20);
-    }
 }

models/BadlyNamed__Class.php

 <?php
 class BadLyNamed__Class extends Doctrine_Record {
-    public function setTableDefinition() {
+    public static function initMetadata($class) {
                                          	
     }
-    public function setUp() { }
 }
 

models/BarRecord.php

 <?php
 class BarRecord extends Doctrine_Record
 {
-    public function setTableDefinition()
+    public static function initMetadata($class)
     {
-    	$this->setTableName('bar');
-    	$this->hasColumn('name', 'string', 200);
-    }
-    public function setUp()
-    {
-        $this->hasMany('FooRecord as Foo', array('local' => 'barId', 'foreign' => 'fooId', 'refClass' => 'FooBarRecord'));
+    	$class->setTableName('bar');
+    	$class->setColumn('name', 'string', 200);
+    	$class->hasMany('FooRecord as Foo', array('local' => 'barId', 'foreign' => 'fooId', 'refClass' => 'FooBarRecord'));
     }
 }

models/BaseSymfonyRecord.php

 <?php
 abstract class BaseSymfonyRecord extends Doctrine_Record
 {
-    public function setUp()
+    public static function initMetadata($class)
     {
-    }
-
-    public function setTableDefinition()
-    {
-        $this->hasColumn('name', 'string', 30);
+        $class->setColumn('name', 'string', 30);
     }
 
 }

models/Blog.php

 <?php
 class Blog extends Doctrine_Record
 {
-    public function setTableDefinition()
+    public static function initMetadata($class)
     {
-    	
-    }
-    public function setUp()
-    {
-        $this->loadTemplate('Taggable');
+    	$class->loadTemplate('Taggable');
     }
 }
 class Taggable extends Doctrine_Template
 {
-    public function setUp()
+    public static function initMetadata($class)
     {
         //$this->hasMany('[Component]TagTemplate as Tag');
     }
 }
 class TagTemplate extends Doctrine_Record
 {
-    public function setTableDefinition()
-    {
-        $this->hasColumn('name', 'string', 100);
-        $this->hasColumn('description', 'string');
-    }
-
-    public function setUp()
+    public static function initMetadata($class)
     {
-        //$this->hasOne('[Component]', array('onDelete' => 'CASCADE'));
+        $class->setColumn('name', 'string', 100);
+        $class->setColumn('description', 'string');
     }
 }

models/BlogTag.php

-<?php 
-class BlogTag extends Doctrine_Record
-{
-    public function setTableDefinition()
+<?php 
+class BlogTag extends Doctrine_Record
+{
+    public static function initMetadata($class)
     {
-        $this->hasColumn('name', 'string', 100);
-        $this->hasColumn('description', 'string');
+        $class->setColumn('name', 'string', 100);
+        $class->setColumn('description', 'string');
+        $class->hasOne('Blog', array('onDelete' => 'CASCADE'));
     }
-    public function setUp()
-    {
-        $this->hasOne('Blog', array('onDelete' => 'CASCADE'));
-    }
-}
+}

models/BoardWithPosition.php

 <?php
 class BoardWithPosition extends Doctrine_Record {
-    public function setTableDefinition() {
-        $this->hasColumn('position', 'integer');
-        $this->hasColumn('category_id', 'integer');
-    }
-    public function setUp() {
-        $this->hasOne('CategoryWithPosition as Category', array('local' => 'category_id', 'foreign' => 'id', 'onDelete' => 'CASCADE'));
+    public static function initMetadata($class) {
+        $class->setColumn('position', 'integer');
+        $class->setColumn('category_id', 'integer');
+        $class->hasOne('CategoryWithPosition as Category', array('local' => 'category_id', 'foreign' => 'id', 'onDelete' => 'CASCADE'));
     }
 }

models/Book.php

 <?php
 class Book extends Doctrine_Record
 {
-    public function setUp()
+    public static function initMetadata($class)
     {
-        $this->hasMany('Author', array('local' => 'id', 'foreign' => 'book_id'));
-        $this->hasOne('User', array('local' => 'user_id',
+        $class->setColumn('user_id', 'integer');
+        $class->setColumn('name', 'string',20);
+        $class->hasMany('Author', array('local' => 'id', 'foreign' => 'book_id'));
+        $class->hasOne('User', array('local' => 'user_id',
                                     'foreign' => 'id',
                                     'onDelete' => 'CASCADE'));
     }
-    public function setTableDefinition()
-    {
-        $this->hasColumn('user_id', 'integer');
-        $this->hasColumn('name', 'string',20);
-    }
 }

models/Bookmark.php

 <?php
 class Bookmark extends Doctrine_Record
 {
-    public function setTableDefinition()
+    public static function initMetadata($class)
     {
-        $this->hasColumn('user_id', 'integer', null, array('primary' => true));
-        $this->hasColumn('page_id', 'integer', null, array('primary' => true));
+        $class->setColumn('user_id', 'integer', null, array('primary' => true));
+        $class->setColumn('page_id', 'integer', null, array('primary' => true));
     }
 }

models/BookmarkUser.php

 <?php
 class BookmarkUser extends Doctrine_Record
 {
-    public function setUp()
+    public static function initMetadata($class)
     {
-    	$this->hasMany('Bookmark as Bookmarks',
+        $class->setColumn('name', 'string', 30);
+    	$class->hasMany('Bookmark as Bookmarks',
                         array('local' => 'id',
                               'foreign' => 'user_id'));
     }
-    public function setTableDefinition()
-    {
-        $this->hasColumn('name', 'string', 30);
-    }
 }

models/BooleanTest.php

 <?php
 class BooleanTest extends Doctrine_Record {
-    public function setTableDefinition() {
-        $this->hasColumn('is_working', 'boolean');
-        $this->hasColumn('is_working_notnull', 'boolean', 1, array('default' => false, 'notnull' => true));
+    public static function initMetadata($class) {
+        $class->setColumn('is_working', 'boolean');
+        $class->setColumn('is_working_notnull', 'boolean', 1, array('default' => false, 'notnull' => true));
     }
 }

models/CPK_Association.php

 <?php
 class CPK_Association extends Doctrine_Record {
-    public function setTableDefinition() {
-        $this->hasColumn('test1_id', 'integer', 11, 'primary');
-        $this->hasColumn('test2_id', 'integer', 11, 'primary');
+    public static function initMetadata($class) {
+        $class->setColumn('test1_id', 'integer', 11, 'primary');
+        $class->setColumn('test2_id', 'integer', 11, 'primary');
     }
 }

models/CPK_Test.php

 <?php
 class CPK_Test extends Doctrine_Record {
-    public function setTableDefinition() {
-        $this->hasColumn('name', 'string', 255);
-    }
-    public function setUp() {
-        $this->hasMany('CPK_Test2 as Test', 'CPK_Association.test2_id');
+    public static function initMetadata($class) {
+        $class->setColumn('name', 'string', 255);
+        $class->hasMany('CPK_Test2 as Test', array('local' => 'test_id', 'foreign' => 'test2_id', 'refClass' => 'CPK_Association'));
     }
 }

models/CPK_Test2.php

 <?php
 class CPK_Test2 extends Doctrine_Record {
-    public function setTableDefinition() {
-        $this->hasColumn('name', 'string', 255);
-    }
-    public function setUp() {
-        $this->hasMany('CPK_Test as Test', 'CPK_Association.test1_id');
+    public static function initMetadata($class) {
+        $class->setColumn('name', 'string', 255);
+        $class->hasMany('CPK_Test as Test', array('local' => 'test2_id', 'test1_id', 'refClass' => 'CPK_Association'));
     }
 }

models/CascadeDeleteRelatedTest.php

 <?php
 class CascadeDeleteRelatedTest extends Doctrine_Record
 {
-    public function setTableDefinition()
+    public static function initMetadata($class)
     {
-        $this->hasColumn('name', 'string');
-        $this->hasColumn('cscd_id', 'integer');
-    }
-    public function setUp()
-    {
-        $this->hasOne('CascadeDeleteTest', array('local' => 'cscd_id', 
+        $class->setColumn('name', 'string');
+        $class->setColumn('cscd_id', 'integer');
+        $class->hasOne('CascadeDeleteTest', array('local' => 'cscd_id', 
                                                  'foreign' => 'id',
                                                  'onDelete' => 'CASCADE',
                                                  'onUpdate' => 'SET NULL'));
 
-        $this->hasMany('CascadeDeleteRelatedTest2 as Related',
+        $class->hasMany('CascadeDeleteRelatedTest2 as Related',
                         array('local' => 'id',
                               'foreign' => 'cscd_id'));
     }

models/CascadeDeleteRelatedTest2.php

 <?php
 class CascadeDeleteRelatedTest2 extends Doctrine_Record
 {
-    public function setTableDefinition()
+    public static function initMetadata($class)
     {
-        $this->hasColumn('name', 'string');
-        $this->hasColumn('cscd_id', 'integer');
-    }
-    public function setUp()
-    {
-        $this->hasOne('CascadeDeleteRelatedTest', array('local' => 'cscd_id',
+        $class->setColumn('name', 'string');
+        $class->setColumn('cscd_id', 'integer');
+        $class->hasOne('CascadeDeleteRelatedTest', array('local' => 'cscd_id',
                                                         'foreign' => 'id',
                                                         'onDelete' => 'SET NULL'));
     }

models/CascadeDeleteTest.php

 <?php
 class CascadeDeleteTest extends Doctrine_Record
 {
-    public function setTableDefinition()
+    public static function initMetadata($class)
     {
-        $this->hasColumn('name', 'string');
-    }
-    public function setUp()
-    {
-        $this->hasMany('CascadeDeleteRelatedTest as Related', 
+        $class->setColumn('name', 'string');
+        $class->hasMany('CascadeDeleteRelatedTest as Related', 
                         array('local' => 'id',
                               'foreign' => 'cscd_id'));
     }

models/CategoryNestedSet.php

 <?php
 class CategoryNestedSet extends Doctrine_Record
 {
-  public function setTableDefinition()
+  public static function initMetadata($class)
   {
-    $this->setTableName('category_nested_set');
-    $this->hasColumn('id', 'integer', 4, array('primary' => true, 'autoincrement' => true));
-    $this->hasColumn('name', 'string', 255, array('notnull' => true));
+    $class->setTableName('category_nested_set');
+    $class->setColumn('id', 'integer', 4, array('primary' => true, 'autoincrement' => true));
+    $class->setColumn('name', 'string', 255, array('notnull' => true));
     
-    $this->actAs('NestedSet');
+    $class->actAs('NestedSet');
   }
-
-  public function setUp()
-  {
-    
-  }
-}
+}
\ No newline at end of file

models/CategoryWithPosition.php

 <?php
 class CategoryWithPosition extends Doctrine_Record {
-    public function setTableDefinition() {
-        $this->hasColumn('position', 'integer');
-        $this->hasColumn('name', 'string', 255);
+    public static function initMetadata($class) {
+        $class->setColumn('position', 'integer');
+        $class->setColumn('name', 'string', 255);
+        $class->hasMany('BoardWithPosition as Boards', array('local' => 'id' , 'foreign' => 'category_id')); 
     }
-    public function setUp() {
-        $this->hasMany('BoardWithPosition as Boards', array('local' => 'id' , 'foreign' => 'category_id')); 
-    }   
 }

models/CheckConstraintTest.php

 <?php
 class CheckConstraintTest extends Doctrine_Record
 {
-    public function setTableDefinition()
+    public static function initMetadata($class)
     {
-        $this->hasColumn('price', 'decimal', 2, array('max' => 5000, 'min' => 100));
-        $this->hasColumn('discounted_price', 'decimal', 2);
-        $this->check('price > discounted_price');
+        $class->setColumn('price', 'decimal', 2, array('max' => 5000, 'min' => 100));
+        $class->setColumn('discounted_price', 'decimal', 2);
+        $class->check('price > discounted_price');
     }
 }

models/ClientModel.php

 <?php
 class ClientModel extends Doctrine_Record
 {
-	public function setTableDefinition() 
+	public static function initMetadata($class) 
     {
-		$this->setTableName('clients');
+		$class->setTableName('clients');
 
-		$this->hasColumn('id', 'integer', 4, array('notnull' => true,
+		$class->setColumn('id', 'integer', 4, array('notnull' => true,
 	                                           'primary' => true,
 	                                           'autoincrement' => true,
 	                                           'unsigned' => true));
-		$this->hasColumn('short_name', 'string', 32, array('notnull' => true, 'notblank', 'unique' => true));
-	}
-
-	public function setUp() 
-    {
-		$this->hasMany('AddressModel', array('local' => 'client_id', 'foreign' => 'address_id', 'refClass' => 'ClientToAddressModel'));
+		$class->setColumn('short_name', 'string', 32, array('notnull' => true, 'notblank', 'unique' => true));
+		$class->hasMany('AddressModel', array('local' => 'client_id', 'foreign' => 'address_id', 'refClass' => 'ClientToAddressModel'));
 	}
 }
 
 class ClientToAddressModel extends Doctrine_Record 
 {
-	public function setTableDefinition() 
-    {
-		$this->setTableName('clients_to_addresses');
-
-		$this->hasColumn('client_id', 'integer', 11, array('primary' => true));
-		$this->hasColumn('address_id', 'integer', 11, array('primary' => true));
-	}
-
-	public function construct()
+	public static function initMetadata($class) 
     {
-	}
+		$class->setTableName('clients_to_addresses');
 
-	public function setUp() 
-    {
-    	$this->hasOne('ClientModel', array('local' => 'client_id', 'foreign' => 'id', 'onDelete' => 'CASCADE'));
-    	$this->hasOne('AddressModel', array('local' => 'address_id', 'foreign' => 'id', 'onDelete' => 'CASCADE'));
+		$class->setColumn('client_id', 'integer', 11, array('primary' => true));
+		$class->setColumn('address_id', 'integer', 11, array('primary' => true));
+		
+		$class->hasOne('ClientModel', array('local' => 'client_id', 'foreign' => 'id', 'onDelete' => 'CASCADE'));
+    	$class->hasOne('AddressModel', array('local' => 'address_id', 'foreign' => 'id', 'onDelete' => 'CASCADE'));
 	}
 }
 
 class AddressModel extends Doctrine_Record 
 {
-	public function setTableDefinition() 
+	public static function initMetadata($class) 
     {
-		$this->setTableName('addresses');
+		$class->setTableName('addresses');
 
-		$this->hasColumn('id', 'integer', 11, array('autoincrement' => true,
+		$class->setColumn('id', 'integer', 11, array('autoincrement' => true,
 													'primary'       => true
 													));
-		$this->hasColumn('address1', 'string', 255, array('notnull' => true, 'notblank'));
-		$this->hasColumn('address2', 'string', 255, array('notnull' => true));
-		$this->hasColumn('city', 'string', 255, array('notnull' => true, 'notblank'));
-		$this->hasColumn('state', 'string', 10, array('notnull' => true, 'notblank', 'usstate'));
-		$this->hasColumn('zip', 'string', 15, array('notnull' => true, 'notblank', 'regexp' => '/^[0-9-]*$/'));
-	}
-
-	public function setUp() 
-    {
-		$this->hasMany('ClientModel', array('local' => 'address_id', 'foreign' => 'client_id', 'refClass' => 'ClientToAddressModel'));
+		$class->setColumn('address1', 'string', 255, array('notnull' => true, 'notblank'));
+		$class->setColumn('address2', 'string', 255, array('notnull' => true));
+		$class->setColumn('city', 'string', 255, array('notnull' => true, 'notblank'));
+		$class->setColumn('state', 'string', 10, array('notnull' => true, 'notblank', 'usstate'));
+		$class->setColumn('zip', 'string', 15, array('notnull' => true, 'notblank', 'regexp' => '/^[0-9-]*$/'));
+		$class->hasMany('ClientModel', array('local' => 'address_id', 'foreign' => 'client_id', 'refClass' => 'ClientToAddressModel'));
 	}
 }

models/ConcreteEmail.php

 <?php
 class ConcreteEmail extends Doctrine_Record
 {
-    public function setUp()
+    public static function initMetadata($class)
     {
-        $this->loadTemplate('EmailTemplate');
+        $class->loadTemplate('EmailTemplate');
     }
 }