AbstractSchema.php

<?php
abstract class ZendDbSchema_Db_Schema_AbstractSchema
    implements IteratorAggregate
{
    const NAME_KEY = 'name';

    protected $_params = array();

    protected $_name;

    abstract protected function _getCleanSchema();

    abstract protected function _getAlterSql();

    abstract protected function _getCreateSql();

    abstract protected function _getDropSql();

    public function isExist()
    {
        $schema = $this->getCleanSchema();
        return !empty($schema);
    }

    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);
        }

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

        return false;
    }

    public function getCleanSchema($param = null)
    {
        $schema = $this->_getCleanSchema();
        if ($param) {
            if (isset($schema[$param])) {
                return $schema[$param];
            }
            return null;
        }
        return $schema;
    }

    public function refresh($param = null)
    {
        if ($param) {
            $this->__set($param, $this->getCleanSchema($param));
        } else {
            $this->setFromArray($this->getCleanSchema());
        }
        return $this;
    }

    public function __construct($name = null)
    {
        if ($name) {
            $this->_name = (string) $name;
        }

        $this->refresh();

        $this->init();
    }

    public function init()
    {
    }

    public function __toString()
    {
        return $this->toSql();
    }

    public function __get($name)
    {
        if (!$this->__isset($name)) {
            return null;
        }
        return $this->_params[$name];
    }

    public function __isset($name)
    {
        return array_key_exists($name, $this->_params);
    }

    public function __set($name, $value)
    {
        $this->_params[$name] = $value;
    }

    public function __unset($name)
    {
        if ($this->__isset($name)) {
            unset($this->_params[$name]);
        }
    }

    public function __clone()
    {
        $this->_name = null;

        $this->__set(self::NAME_KEY, null);

        $this->reload();
    }

    public function getIterator()
    {
        return new ArrayIterator($this->toArray());
    }

    public function setFromArray(array $schema)
    {
        foreach ($schema as $keyName => $value) {
            $this->__set($keyName, $value);
        }

        return $this;
    }

    public function toArray()
    {
        return $this->_params;
    }

    public function setName($name)
    {
        $this->__set(self::NAME_KEY, (string) $name);
        return $this;
    }

    public function getName()
    {
        return $this->__get(self::NAME_KEY);
    }

    public function getOriginName()
    {
        if ($this->_name) {
            return $this->_name;
        }
        return $this->getName();
    }

    public function getDropSql()
    {
        if (!$this->isExist()) {
            throw new ZendDbSchema_Db_Schema_Exception('Definition is not exist');
        }
        return $this->_getDropSql();
    }

    public function toSql($alter = false)
    {
        if ($alter) {
            if ($this->isDirty() && $this->isExist()) {
                return $this->_getAlterSql();
            }
            return '';
        }
        return $this->_getCreateSql();
    }
}