ZF-3486

- Promoted Zend_Db_Table concrete usage to trunk

git-svn-id: http://framework.zend.com/svn/framework/standard/trunk@16733 44c647ce-9c0f-0410-b52a-842ac1e357ba

library/Zend/Db/Table.php

@@ -26,6 +26,11 @@
 require_once 'Zend/Db/Table/Abstract.php';
 
 /**
+ * @see Zend_Db_Table_Definition
+ */
+require_once 'Zend/Db/Table/Definition.php';
+
+/**
  * Class for SQL table interface.
  *
  * @category   Zend
@@ -33,8 +38,47 @@ require_once 'Zend/Db/Table/Abstract.php';
  * @subpackage Table
  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  * @license    http://framework.zend.com/license/new-bsd     New BSD License
- * @deprecated since 0.9
  */
-abstract class Zend_Db_Table extends Zend_Db_Table_Abstract
+class Zend_Db_Table extends Zend_Db_Table_Abstract
 {
+    
+    /**
+     * __construct() - For concrete implementation of Zend_Db_Table
+     *
+     * @param string|array $config string can reference a Zend_Registry key for a db adapter
+     *                             OR it can refernece the name of a table
+     * @param unknown_type $definition 
+     */
+    public function __construct($config = array(), $definition = null)
+    {
+        if ($definition !== null && is_array($definition)) {
+            $definition = new Zend_Db_Table_Definition($definition);
+        }
+        
+        if (is_string($config)) {
+            if (Zend_Registry::isRegistered($config)) {
+                trigger_error(__CLASS__ . '::' . __METHOD__ . '(\'registryName\') is not valid usage of Zend_Db_Table, '
+                    . 'try extending Zend_Db_Table_Abstract in your extending classes.',
+                    E_USER_NOTICE
+                    );
+                $config = array(self::ADAPTER => $config);
+            } else {
+                // process this as table with or without a definition
+                if ($definition instanceof Zend_Db_Table_Definition
+                    && $definition->hasTableConfig($config)) {
+                    // this will have DEFINITION_CONFIG_NAME & DEFINITION
+                    $config = $definition->getTableConfig($config);
+                } else {
+                    $config = array(self::NAME => $config);
+                }
+            }
+        }
+        
+        parent::__construct($config);
+    }
+    
+    
+    
+
+    
 }

library/Zend/Db/Table/Abstract.php

@@ -48,6 +48,8 @@ abstract class Zend_Db_Table_Abstract
 {
 
     const ADAPTER          = 'db';
+    const DEFINITION        = 'definition';
+    const DEFINITION_CONFIG_NAME = 'definitionConfigName';
     const SCHEMA           = 'schema';
     const NAME             = 'name';
     const PRIMARY          = 'primary';
@@ -86,6 +88,20 @@ abstract class Zend_Db_Table_Abstract
     protected static $_defaultDb;
 
     /**
+     * Optional Zend_Db_Table_Definition object
+     *
+     * @var unknown_type
+     */
+    protected $_definition = null;
+    
+    /**
+     * Optional definition config name used in concrete implementation
+     *
+     * @var string
+     */
+    protected $_definitionConfigName = null;
+    
+    /**
      * Default cache for information provided by the adapter's describeTable() method.
      *
      * @var Zend_Cache_Core
@@ -245,11 +261,33 @@ abstract class Zend_Db_Table_Abstract
             $config = array(self::ADAPTER => $config);
         }
 
-        foreach ($config as $key => $value) {
+        if ($config) {
+            $this->setOptions($config);
+        }
+
+        $this->_setup();
+        $this->init();
+    }
+
+    /**
+     * setOptions()
+     *
+     * @param array $options
+     * @return Zend_Db_Table_Abstract
+     */
+    public function setOptions(Array $options)
+    {
+        foreach ($options as $key => $value) {
             switch ($key) {
                 case self::ADAPTER:
                     $this->_setAdapter($value);
                     break;
+                case self::DEFINITION:
+                    $this->setDefinition($value);
+                    break;
+                case self::DEFINITION_CONFIG_NAME:
+                    $this->setDefinitionConfigName($value);
+                    break;
                 case self::SCHEMA:
                     $this->_schema = (string) $value;
                     break;
@@ -286,8 +324,51 @@ abstract class Zend_Db_Table_Abstract
             }
         }
 
-        $this->_setup();
-        $this->init();
+        return $this;
+    }
+    
+    /**
+     * setDefinition()
+     *
+     * @param Zend_Db_Table_Definition $definition
+     * @return Zend_Db_Table_Abstract
+     */
+    public function setDefinition(Zend_Db_Table_Definition $definition)
+    {
+        $this->_definition = $definition;
+        return $this;
+    }
+    
+    /**
+     * getDefinition()
+     *
+     * @return Zend_Db_Table_Definition|null
+     */
+    public function getDefinition()
+    {
+        return $this->_definition;
+    }
+    
+    /**
+     * setDefinitionConfigName()
+     *
+     * @param string $definition
+     * @return Zend_Db_Table_Abstract
+     */
+    public function setDefinitionConfigName($definitionConfigName)
+    {
+        $this->_definitionConfigName = $definitionConfigName;
+        return $this;
+    }
+    
+    /**
+     * getDefinitionConfigName()
+     *
+     * @return string
+     */
+    public function getDefinitionConfigName()
+    {
+        return $this->_definitionConfigName;
     }
 
     /**
@@ -379,6 +460,9 @@ abstract class Zend_Db_Table_Abstract
     public function getReference($tableClassname, $ruleKey = null)
     {
         $thisClass = get_class($this);
+        if ($thisClass === 'Zend_Db_Table') {
+            $thisClass = $this->_definitionConfigName;
+        }
         $refMap = $this->_getReferenceMapNormalized();
         if ($ruleKey !== null) {
             if (!isset($refMap[$ruleKey])) {

library/Zend/Db/Table/Definition.php

@@ -0,0 +1,130 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Db
+ * @subpackage Table
+ * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+
+/**
+ * Class for SQL table interface.
+ *
+ * @category   Zend
+ * @package    Zend_Db
+ * @subpackage Table
+ * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Db_Table_Definition
+{
+    
+    /**
+     * @var array
+     */
+    protected $_tableConfigs = array();
+    
+    /**
+     * __construct()
+     *
+     * @param array|Zend_Config $options
+     */
+    public function __construct($options = null)
+    {
+        if ($options instanceof Zend_Config) {
+            $this->setConfig($options);
+        } elseif (is_array($options)) {
+            $this->setOptions($options);
+        }
+    }
+    
+    /**
+     * setConfig()
+     *
+     * @param Zend_Config $config
+     * @return Zend_Db_Table_Definition
+     */
+    public function setConfig(Zend_Config $config)
+    {
+        $this->setOptions($config->toArray());
+        return $this;
+    }
+    
+    /**
+     * setOptions()
+     *
+     * @param array $options
+     * @return Zend_Db_Table_Definition
+     */
+    public function setOptions(Array $options)
+    {
+        foreach ($options as $optionName => $optionValue) {
+            $this->setTableConfig($optionName, $optionValue);
+        }
+        return $this;
+    }
+    
+    /**
+     * @var string $tableName
+     * @var array  $tableConfig
+     * @return Zend_Db_Table_Definition
+     */
+    public function setTableConfig($tableName, array $tableConfig)
+    {
+        // @todo logic here
+        $tableConfig[Zend_Db_Table::DEFINITION_CONFIG_NAME] = $tableName;
+        $tableConfig[Zend_Db_Table::DEFINITION] = $this;
+        
+        if (!isset($tableConfig[Zend_Db_Table::NAME])) {
+            $tableConfig[Zend_Db_Table::NAME] = $tableName;
+        }
+        
+        $this->_tableConfigs[$tableName] = $tableConfig;
+        return $this;
+    }
+    
+    /**
+     * getTableConfig()
+     *
+     * @param string $tableName
+     * @return array
+     */
+    public function getTableConfig($tableName)
+    {
+        return $this->_tableConfigs[$tableName];
+    }
+    
+    /**
+     * removeTableConfig()
+     *
+     * @param string $tableName
+     */
+    public function removeTableConfig($tableName)
+    {
+        unset($this->_tableConfigs[$tableName]);
+    }
+    
+    /**
+     * hasTableConfig()
+     *
+     * @param string $tableName
+     * @return bool
+     */
+    public function hasTableConfig($tableName)
+    {
+        return (isset($this->_tableConfigs[$tableName]));
+    }
+
+}

library/Zend/Db/Table/Row/Abstract.php

@@ -116,12 +116,8 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
         if (isset($config['table']) && $config['table'] instanceof Zend_Db_Table_Abstract) {
             $this->_table = $config['table'];
             $this->_tableClass = get_class($this->_table);
-        } else if ($this->_tableClass !== null) {
-            if (!class_exists($this->_tableClass)) {
-                require_once 'Zend/Loader.php';
-                Zend_Loader::loadClass($this->_tableClass);
-            }
-            $this->_table = new $this->_tableClass();
+        } elseif ($this->_tableClass !== null) {
+            $this->_table = $this->_getTableFromString($this->_tableClass);
         }
 
         if (isset($config['data'])) {
@@ -545,20 +541,10 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
         if (count($pkDiffData) > 0) {
             $depTables = $this->_getTable()->getDependentTables();
             if (!empty($depTables)) {
-                $db = $this->_getTable()->getAdapter();
                 $pkNew = $this->_getPrimaryKey(true);
                 $pkOld = $this->_getPrimaryKey(false);
                 foreach ($depTables as $tableClass) {
-                    if (!class_exists($tableClass)) {
-                        try {
-                            require_once 'Zend/Loader.php';
-                            Zend_Loader::loadClass($tableClass);
-                        } catch (Zend_Exception $e) {
-                            require_once 'Zend/Db/Table/Row/Exception.php';
-                            throw new Zend_Db_Table_Row_Exception($e->getMessage());
-                        }
-                    }
-                    $t = new $tableClass(array('db' => $db));
+                    $t = $this->_getTableFromString($tableClass);
                     $t->_cascadeUpdate($this->getTableClass(), $pkOld, $pkNew);
                 }
             }
@@ -627,19 +613,9 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
          */
         $depTables = $this->_getTable()->getDependentTables();
         if (!empty($depTables)) {
-            $db = $this->_getTable()->getAdapter();
             $pk = $this->_getPrimaryKey();
             foreach ($depTables as $tableClass) {
-                if (!class_exists($tableClass)) {
-                    try {
-                        require_once 'Zend/Loader.php';
-                        Zend_Loader::loadClass($tableClass);
-                    } catch (Zend_Exception $e) {
-                        require_once 'Zend/Db/Table/Row/Exception.php';
-                        throw new Zend_Db_Table_Row_Exception($e->getMessage());
-                    }
-                }
-                $t = new $tableClass(array('db' => $db));
+                $t = $this->_getTableFromString($tableClass);
                 $t->_cascadeDelete($this->getTableClass(), $pk);
             }
         }
@@ -859,7 +835,8 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
      */
     protected function _prepareReference(Zend_Db_Table_Abstract $dependentTable, Zend_Db_Table_Abstract $parentTable, $ruleKey)
     {
-        $map = $dependentTable->getReference(get_class($parentTable), $ruleKey);
+        $parentTableName = (get_class($parentTable) === 'Zend_Db_Table') ? $parentTable->getDefinitionConfigName() : get_class($parentTable);
+        $map = $dependentTable->getReference($parentTableName, $ruleKey);
 
         if (!isset($map[Zend_Db_Table_Abstract::REF_COLUMNS])) {
             $parentInfo = $parentTable->info();
@@ -886,18 +863,10 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
         $db = $this->_getTable()->getAdapter();
 
         if (is_string($dependentTable)) {
-            if (!class_exists($dependentTable)) {
-                try {
-                    require_once 'Zend/Loader.php';
-                    Zend_Loader::loadClass($dependentTable);
-                } catch (Zend_Exception $e) {
-                    require_once 'Zend/Db/Table/Row/Exception.php';
-                    throw new Zend_Db_Table_Row_Exception($e->getMessage());
-                }
-            }
-            $dependentTable = new $dependentTable(array('db' => $db));
+            $dependentTable = $this->_getTableFromString($dependentTable);
         }
-        if (! $dependentTable instanceof Zend_Db_Table_Abstract) {
+        
+        if (!$dependentTable instanceof Zend_Db_Table_Abstract) {
             $type = gettype($dependentTable);
             if ($type == 'object') {
                 $type = get_class($dependentTable);
@@ -906,6 +875,13 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
             throw new Zend_Db_Table_Row_Exception("Dependent table must be a Zend_Db_Table_Abstract, but it is $type");
         }
 
+        // even if we are interacting between a table defined in a class and a
+        // table via extension, ensure to persist the definition
+        if (($tableDefinition = $this->_table->getDefinition()) !== null
+            && ($dependentTable->getDefinition() == null)) {
+            $dependentTable->setOptions(array(Zend_Db_Table_Abstract::DEFINITION => $tableDefinition));
+        }
+
         if ($select === null) {
             $select = $dependentTable->select();
         } else {
@@ -943,18 +919,10 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
         $db = $this->_getTable()->getAdapter();
 
         if (is_string($parentTable)) {
-            if (!class_exists($parentTable)) {
-                try {
-                    require_once 'Zend/Loader.php';
-                    Zend_Loader::loadClass($parentTable);
-                } catch (Zend_Exception $e) {
-                    require_once 'Zend/Db/Table/Row/Exception.php';
-                    throw new Zend_Db_Table_Row_Exception($e->getMessage());
-                }
-            }
-            $parentTable = new $parentTable(array('db' => $db));
+            $parentTable = $this->_getTableFromString($parentTable);
         }
-        if (! $parentTable instanceof Zend_Db_Table_Abstract) {
+        
+        if (!$parentTable instanceof Zend_Db_Table_Abstract) {
             $type = gettype($parentTable);
             if ($type == 'object') {
                 $type = get_class($parentTable);
@@ -963,6 +931,13 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
             throw new Zend_Db_Table_Row_Exception("Parent table must be a Zend_Db_Table_Abstract, but it is $type");
         }
 
+        // even if we are interacting between a table defined in a class and a
+        // table via extension, ensure to persist the definition
+        if (($tableDefinition = $this->_table->getDefinition()) !== null
+            && ($parentTable->getDefinition() == null)) {
+            $parentTable->setOptions(array(Zend_Db_Table_Abstract::DEFINITION => $tableDefinition));
+        }
+        
         if ($select === null) {
             $select = $parentTable->select();
         } else {
@@ -971,6 +946,7 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
 
         $map = $this->_prepareReference($this->_getTable(), $parentTable, $ruleKey);
 
+        // iterate the map, creating the proper wheres
         for ($i = 0; $i < count($map[Zend_Db_Table_Abstract::COLUMNS]); ++$i) {
             $dependentColumnName = $db->foldCase($map[Zend_Db_Table_Abstract::COLUMNS][$i]);
             $value = $this->_data[$dependentColumnName];
@@ -979,8 +955,18 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
             $parentColumnName = $parentDb->foldCase($map[Zend_Db_Table_Abstract::REF_COLUMNS][$i]);
             $parentColumn = $parentDb->quoteIdentifier($parentColumnName, true);
             $parentInfo = $parentTable->info();
-            $type = $parentInfo[Zend_Db_Table_Abstract::METADATA][$parentColumnName]['DATA_TYPE'];
-            $select->where("$parentColumn = ?", $value, $type);
+            
+            // determine where part
+            $type     = $parentInfo[Zend_Db_Table_Abstract::METADATA][$parentColumnName]['DATA_TYPE'];
+            $nullable = $parentInfo[Zend_Db_Table_Abstract::METADATA][$parentColumnName]['NULLABLE'];
+            if ($value === null && $nullable == true) {
+                $select->where("$parentColumn IS NULL");
+            } elseif ($value === null && $nullable == false) {
+                return null;
+            } else {
+                $select->where("$parentColumn = ?", $value, $type);
+            }
+            
         }
 
         return $parentTable->fetchRow($select);
@@ -1001,18 +987,10 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
         $db = $this->_getTable()->getAdapter();
 
         if (is_string($intersectionTable)) {
-            if (!class_exists($intersectionTable)) {
-                try {
-                    require_once 'Zend/Loader.php';
-                    Zend_Loader::loadClass($intersectionTable);
-                } catch (Zend_Exception $e) {
-                    require_once 'Zend/Db/Table/Row/Exception.php';
-                    throw new Zend_Db_Table_Row_Exception($e->getMessage());
-                }
-            }
-            $intersectionTable = new $intersectionTable(array('db' => $db));
+            $intersectionTable = $this->_getTableFromString($intersectionTable);
         }
-        if (! $intersectionTable instanceof Zend_Db_Table_Abstract) {
+        
+        if (!$intersectionTable instanceof Zend_Db_Table_Abstract) {
             $type = gettype($intersectionTable);
             if ($type == 'object') {
                 $type = get_class($intersectionTable);
@@ -1021,18 +999,17 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
             throw new Zend_Db_Table_Row_Exception("Intersection table must be a Zend_Db_Table_Abstract, but it is $type");
         }
 
+        // even if we are interacting between a table defined in a class and a
+        // table via extension, ensure to persist the definition
+        if (($tableDefinition = $this->_table->getDefinition()) !== null
+            && ($intersectionTable->getDefinition() == null)) {
+            $intersectionTable->setOptions(array(Zend_Db_Table_Abstract::DEFINITION => $tableDefinition));
+        }
+        
         if (is_string($matchTable)) {
-            if (!class_exists($matchTable)) {
-                try {
-                    require_once 'Zend/Loader.php';
-                    Zend_Loader::loadClass($matchTable);
-                } catch (Zend_Exception $e) {
-                    require_once 'Zend/Db/Table/Row/Exception.php';
-                    throw new Zend_Db_Table_Row_Exception($e->getMessage());
-                }
-            }
-            $matchTable = new $matchTable(array('db' => $db));
+            $matchTable = $this->_getTableFromString($matchTable);
         }
+        
         if (! $matchTable instanceof Zend_Db_Table_Abstract) {
             $type = gettype($matchTable);
             if ($type == 'object') {
@@ -1042,6 +1019,13 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
             throw new Zend_Db_Table_Row_Exception("Match table must be a Zend_Db_Table_Abstract, but it is $type");
         }
 
+        // even if we are interacting between a table defined in a class and a
+        // table via extension, ensure to persist the definition
+        if (($tableDefinition = $this->_table->getDefinition()) !== null
+            && ($matchTable->getDefinition() == null)) {
+            $matchTable->setOptions(array(Zend_Db_Table_Abstract::DEFINITION => $tableDefinition));
+        }
+        
         if ($select === null) {
             $select = $matchTable->select();
         } else {
@@ -1168,4 +1152,46 @@ abstract class Zend_Db_Table_Row_Abstract implements ArrayAccess
         throw new Zend_Db_Table_Row_Exception("Unrecognized method '$method()'");
     }
 
+
+    /**
+     * _getTableFromString
+     *
+     * @param string $tableName
+     * @return Zend_Db_Table_Abstract
+     */
+    protected function _getTableFromString($tableName)
+    {
+
+        if ($this->_table instanceof Zend_Db_Table_Abstract) {
+            $tableDefinition = $this->_table->getDefinition();
+            
+            if ($tableDefinition !== null && $tableDefinition->hasTableConfig($tableName)) {
+                return new Zend_Db_Table($tableName, $tableDefinition);
+            } 
+        }
+                
+        // assume the tableName is the class name
+        if (!class_exists($tableName)) {
+            try {
+                require_once 'Zend/Loader.php';
+                Zend_Loader::loadClass($tableName);
+            } catch (Zend_Exception $e) {
+                require_once 'Zend/Db/Table/Row/Exception.php';
+                throw new Zend_Db_Table_Row_Exception($e->getMessage());
+            }
+        }
+
+        $options = array();
+        
+        if (($table = $this->_getTable())) {
+            $options['db'] = $table->getAdapter();
+        }
+        
+        if (isset($tableDefinition) && $tableDefinition !== null) {
+            $options[Zend_Db_Table_Abstract::DEFINITION] = $tableDefinition;
+        }
+
+        return new $tableName($options);
+    }
+
 }

tests/Zend/Db/Table/Relationships/TestCommon.php

@@ -1100,6 +1100,35 @@ abstract class Zend_Db_Table_Relationships_TestCommon extends Zend_Db_Table_Test
         $this->assertEquals(1, $destRows->count());
     }
     
+    /**
+     * @group ZF-3486
+     */
+    public function testTableRelationshipCanFindParentViaConcreteInstantiation()
+    {
+        Zend_Db_Table::setDefaultAdapter($this->_db);
+        $definition = array(
+            'Bugs' => array(
+                'name' => 'zfbugs',
+                'referenceMap' => array(
+                    'Engineer' => array(
+                        'columns'           => 'assigned_to',
+                        'refTableClass'     => 'Accounts',
+                        'refColumns'        => 'account_name'
+                        )
+                    )        
+                ),
+            'Accounts' => array(
+                'name' => 'zfaccounts'
+                )
+
+            );
+        $bugsTable = new Zend_Db_Table('Bugs', $definition);
+        $rowset = $bugsTable->find(1);
+        $row = $rowset->current();
+        $parent = $row->findParentRow('Accounts', 'Engineer');
+        $this->assertEquals('mmouse', $parent->account_name);
+        Zend_Db_Table::setDefaultAdapter();
+    }
     
     
     /**

tests/Zend/Db/Table/TestCommon.php

@@ -32,6 +32,10 @@ require_once 'Zend/Db/Table/TestSetup.php';
  */
 require_once 'Zend/Registry.php';
 
+/**
+ * @see Zend_Db_Table
+ */
+require_once 'Zend/Db/Table.php';
 
 PHPUnit_Util_Filter::addFileToFilter(__FILE__);
 
@@ -1497,6 +1501,30 @@ abstract class Zend_Db_Table_TestCommon extends Zend_Db_Table_TestSetup
     }
 
     /**
+     * @group ZF-3486
+     */
+    public function testTableConcreteInstantiation()
+    {
+        Zend_Db_Table::setDefaultAdapter($this->_db);
+        
+        $table = new Zend_Db_Table('zfbugs');
+        $rowset = $table->find(1);
+        $this->assertEquals(1, count($rowset));
+        
+        Zend_Db_Table::setDefaultAdapter();
+        
+        $table = new Zend_Db_Table(array(
+            'name' => 'zfbugs',
+            'db' => $this->_db
+            ));
+        $rowset = $table->find(1);
+        $this->assertEquals(1, count($rowset));
+    }
+    
+    
+    
+    
+    /**
      * Returns a clean Zend_Cache_Core with File backend
      *
      * @return Zend_Cache_Core
@@ -1560,5 +1588,7 @@ abstract class Zend_Db_Table_TestCommon extends Zend_Db_Table_TestSetup
 
         return $cacheFrontend;
     }
+    
+    
 
 }