Table.php

<?php
class ZendDbSchema_Db_Schema_Table extends ZendDbSchema_Db_Schema_AbstractEntity 
{
    const CHARSET_KEY  = 'charset';

    const COLUMNS_KEY  = 'columns';
    const INDEXES_KEY  = 'indexes';
    const FOREIGNS_KEY = 'foreigns';
    const PRIMARY_KEY  = 'primary';

    protected $_columnsManagerClass = 'ZendDbSchema_Db_Schema_Table_DefinitionManager_Column';

    protected $_indexesManagerClass = 'ZendDbSchema_Db_Schema_Table_DefinitionManager_Index';

    protected $_foreignsManagerClass = 'ZendDbSchema_Db_Schema_Table_DefinitionManager_ForeignKey';

    protected $_columnClass = 'ZendDbSchema_Db_Schema_Table_Column';

    protected $_indexClass = 'ZendDbSchema_Db_Schema_Table_Index';

    protected $_foreignClass = 'ZendDbSchema_Db_Schema_Table_ForeignKey';

    protected $_primaryKeyClass = 'ZendDbSchema_Db_Schema_Table_PrimaryKey';

    protected $_columns;

    protected $_indexes;

    protected $_foreigns;

    protected $_primary;

    protected $_loader;

    public function __construct(
            $name = null,
            ZendDbSchema_Db_Adapter_SchemaCompatible $adapter = null,
            ZendDbSchema_Db_Schema_Loader_Table      $loader = null,
            ZendDbSchema_Db_Schema_Generator_Table   $generator = null)
    {
        if (!$adapter) {
            $adapter = self::getDefaultAdapter();
        }

        if (!$loader || !$generator) {
            switch (true) {
                case $adapter instanceof Zend_Db_Adapter_Mysqli:
                case $adapter instanceof Zend_Db_Adapter_Pdo_Mysql:
                    if (!$loader) {
                        $loader = new ZendDbSchema_Db_Schema_Loader_Mysql_Table();
                    }
                    if (!$generator) {
                        $generator = new ZendDbSchema_Db_Schema_Generator_Mysql_Table();
                    }
                    break;
            }
        }
        //TODO check that adapter, generator and loader are same type

        $this->_generator = $generator;
        $this->_loader = $loader;
        $this->_adapter = $adapter;

        parent::__construct($name);
    }

    public function __set($name, $value)
    {
        if (self::NAME_KEY == $name && $value) {
            if ($this->_name != $value && $this->getAdapter()->hasTable($value)) {
                throw new ZendDbSchema_Db_Schema_Exception("Table with name '{$value}' already exists");
            }
        }
        parent::__set($name, $value);
    }

    public function __clone()
    {
        parent::__clone();

        $schema = $this->toArray();
        $this->_indexes = $this->_columns = $this->_primary = $this->_foreigns = null;

        $this->setFromArray($schema);
    }

    public function getColumnClass()
    {
        return $this->_columnClass;
    }

    public function getIndexClass()
    {
        return $this->_indexClass;
    }

    public function getForeignClass()
    {
        return $this->_foreignClass;
    }

    public function setFromArray(array $schema)
    {
        $columns = array();
        if (!empty($schema[self::COLUMNS_KEY])) {
            $columns = $schema[self::COLUMNS_KEY];
        }
        $this->columns()->setFromArray($columns);

        $index = array();
        if (!empty($schema[self::INDEXES_KEY])) {
            $index = $schema[self::INDEXES_KEY];
        }
        $this->indexes()->setFromArray($index);

        $foreign = array();
        if (!empty($schema[self::FOREIGNS_KEY])) {
            $foreign = $schema[self::FOREIGNS_KEY];
        }
        $this->foreigns()->setFromArray($foreign);

        $primary = array();
        if (!empty($schema[self::PRIMARY_KEY])) {
            $primary = $schema[self::PRIMARY_KEY];
        }
        $this->primary()->setFromArray($primary);

        unset(
            $schema[self::COLUMNS_KEY],
            $schema[self::INDEXES_KEY],
            $schema[self::FOREIGNS_KEY],
            $schema[self::PRIMARY_KEY]
        );

        return parent::setFromArray($schema);
    }

    public function toArray()
    {
        $schema = parent::toArray();

        $schema[self::COLUMNS_KEY]  = $this->columns()->toArray();
        $schema[self::PRIMARY_KEY]  = $this->primary()->toArray();
        $schema[self::INDEXES_KEY]  = $this->indexes()->toArray();
        $schema[self::FOREIGNS_KEY] = $this->foreigns()->toArray();

        return $schema;
    }

    public function columns()
    {
        if (!$this->_columns) {
            $this->_columns = new $this->_columnsManagerClass($this);
        }
        return $this->_columns;
    }

    public function primary(ZendDbSchema_Db_Schema_Table_PrimaryKey $primary = null)
    {
        if ($primary) {
            $this->_primary = $primary;
        } elseif (!$this->_primary) {
            $this->_primary = new $this->_primaryKeyClass($this);
        }
        return $this->_primary;
    }

    public function indexes()
    {
        if (!$this->_indexes) {
            $this->_indexes = new $this->_indexesManagerClass($this);
        }
        return $this->_indexes;
    }

    public function foreigns()
    {
        if (!$this->_foreigns) {
            $this->_foreigns = new $this->_foreignsManagerClass($this);
        }
        return $this->_foreigns;
    }

    public function toSql($alter = false)
    {
        if ($alter && (!$this->isExist() || !$this->isDirty())) {
            return '';
        }
        $query = array();
        $query[] = parent::toSql($alter);

        foreach ($this->columns() as $column) {
            if ($alter && $column->isDirty()) {
                $query[] = $column->toSql($alter);
            }
        }
        foreach ($this->indexes() as $index) {
            if (!$alter || $index->isDirty()) {
                $query[] = $index->toSql($alter);
            }
        }

        if (!$alter || $this->primary()->isDirty()) {
            $query[] = $this->primary()->toSql($alter);
        }

        foreach ($this->foreigns() as $foreignKey) {
            if (!$alter || $foreignKey->isDirty()) {
                $query[] = $foreignKey->toSql($alter);
            }
        }

        return join(';' . PHP_EOL, array_filter($query));
    }

    public function isDirty($param = null)
    {
        $clean = $this->getCleanSchema();

        if ($param) {
            if (!array_key_exists($param, $clean)) {
                return $this->__isset($param);
            }
            return $this->getCleanSchema($param) != $this->__get($param);
        }

        unset(
            $clean[self::COLUMNS_KEY],
            $clean[self::INDEXES_KEY],
            $clean[self::PRIMARY_KEY],
            $clean[self::FOREIGNS_KEY]
        );

        if (count($clean) != count($this->_params)) {
            return true;
        }
        foreach ($this->_params as $paramName => $paramValue) {
            if ($this->isDirty($paramName)) {
                return true;
            }
        }

        if ($this->columns()->isDirty()
           || $this->indexes()->isDirty()
           || $this->foreigns()->isDirty()
           || $this->primary()->isDirty()) {
            return true;
        }
        return false;
    }

    protected function _getAlterSql()
    {
        return $this->getGenerator()->alterTable($this);
    }

    protected function _getCreateSql()
    {
        return $this->getGenerator()->createTable($this);
    }

    protected function _getDropSql()
    {
        return $this->getGenerator()->dropTable($this);
    }

    protected function _doReload()
    {
        $this->_cleanSchema = $this->_loader->load(
            $this->getAdapter(),
            $this->getOriginName()
        );
    }
}