TableDataGateway.php

浏览该文件的文档。

<?php
// FleaPHP Framework
//
// Copyright (c) 2005 - 2008 QeeYuan China Inc. (http://www.qeeyuan.com)
//
// 许可协议，请查看源代码中附带的 LICENSE.txt 文件，
// 或者访问 http://www.fleaphp.org/ 获得详细信息。

// {{{ includes
FLEA::loadClass('FLEA_Db_TableLink');
// }}}

// {{{ constants
define('HAS_ONE',       1);

define('BELONGS_TO',    2);

define('HAS_MANY',      3);

define('MANY_TO_MANY',  4);
// }}}

class FLEA_Db_TableDataGateway
{
    var $schema = '';

    var $tableName = null;

    var $fullTableName = null;

    var $primaryKey = null;

    var $hasOne = null;

    var $belongsTo = null;

    var $hasMany = null;

    var $manyToMany = null;

    var $meta = null;

    var $fields = null;

    var $autoValidating = false;

    var $verifier = null;

    var $validateRules = null;

    var $createdTimeFields = array('CREATED', 'CREATED_ON', 'CREATED_AT');

    var $updatedTimeFields = array('UPDATED', 'UPDATED_ON', 'UPDATED_AT');

    var $autoLink = true;

    var $dbo = null;

    var $links = array();

    var $qtableName;

    var $qpk;

    var $pka;

    var $qpka;

    var $lastValidationResult;

    function FLEA_Db_TableDataGateway($params = null)
    {
        if (!empty($params['schema'])) {
            $this->schema = $params['schema'];
        }
        if (!empty($params['tableName'])) {
            $this->tableName = $params['tableName'];
        }

        if (!empty($params['primaryKey'])) {
            $this->primaryKey = $params['primaryKey'];
        }

        // 初始化验证服务对象
        if (isset($params['autoValidating'])) {
            $this->autoValidating = $params['autoValidating'];
        }
        if ($this->autoValidating) {
            if (!empty($params['verifierProvider'])) {
                $provider = $params['verifierProvider'];
            } else {
                $provider = FLEA::getAppInf('helper.verifier');
            }
            if (!empty($provider)) {
                $this->verifier =& FLEA::getSingleton($provider);
            }
        }

        // 当 skipInit 为 true 时，不初始化表数据入口对象
        if (isset($params['skipConnect']) && $params['skipConnect'] != false) {
            return;
        }

        // 初始化数据访问对象
        if (!isset($params['dbo'])) {
            if (isset($params['dbDSN'])) {
                $dbo =& FLEA::getDBO($params['dbDSN']);
            } else {
                $dbo =& FLEA::getDBO();
            }
        } else {
            $dbo =& $params['dbo'];
        }
        $this->setDBO($dbo);

        // 当 skipCreateLinks 不为 true 时，建立关联
        if (!isset($params['skipCreateLinks']) || $params['skipCreateLinks'] == false) {
            $this->relink();
        }
    }

    function setDBO(& $dbo)
    {
        $this->dbo =& $dbo;

        if (empty($this->schema) && !empty($dbo->dsn['schema'])) {
            $this->schema = $dbo->dsn['schema'];
        }
        if (empty($this->fullTableName)) {
            $this->fullTableName = $dbo->dsn['prefix'] . $this->tableName;
        }
        $this->qtableName = $dbo->qtable($this->fullTableName, $this->schema);

        if (!$this->_prepareMeta()) {
            return false;
        }
        $this->fields = array_keys($this->meta);

        if (is_array($this->validateRules)) {
            foreach ($this->validateRules as $fieldName => $rules) {
                $fieldName = strtoupper($fieldName);
                if (!isset($this->meta[$fieldName])) { continue; }
                foreach ((array)$rules as $ruleName => $rule) {
                    $this->meta[$fieldName][$ruleName] = $rule;
                }
            }
        }

        // 如果没有指定主键，则尝试自动获取
        if (empty($this->primaryKey)) {
            foreach ($this->meta as $field) {
                if ($field['primaryKey']) {
                    $this->primaryKey = $field['name'];
                    break;
                }
            }
        }

        if (is_array($this->primaryKey)) {
            $this->qpk = array();
            $this->pka = array();
            $this->qpka = array();
            foreach ($this->primaryKey as $pk) {
                $qpk = $dbo->qfield($pk, $this->fullTableName, $this->schema);
                $this->qpk[$pk] = $qpk;
                $pka = 'flea_pkref_' . $pk;
                $this->pka[$pk] = $pka;
                $this->qpka[$pk] = $qpk . ' AS ' . $pka;
            }
        } else {
            $this->qpk = $dbo->qfield($this->primaryKey, $this->fullTableName, $this->schema);
            $this->pka = 'flea_pkref_' . $this->primaryKey;
            $this->qpka = $this->qpk . ' AS ' . $this->pka;
        }

        return true;
    }

    function & getDBO()
    {
        return $this->dbo;
    }

    function & find($conditions, $sort = null, $fields = '*', $queryLinks = true)
    {
        $rowset =& $this->findAll($conditions, $sort, 1, $fields, $queryLinks);
        if (is_array($rowset)) {
            $row = reset($rowset);
        } else {
            $row = false;
        }
        unset($rowset);
        return $row;
    }

    function & findAll($conditions = null, $sort = null, $limit = null, $fields = '*', $queryLinks = true)
    {
        list($whereby, $distinct) = $this->getWhere($conditions);
        // 处理排序
        $sortby = $sort != '' ? " ORDER BY {$sort}" : '';
        // 处理 $limit
        if (is_array($limit)) {
            list($length, $offset) = $limit;
        } else {
            $length = $limit;
            $offset = null;
        }

        // 构造从主表查询数据的 SQL 语句
        $enableLinks = count($this->links) > 0 && $this->autoLink && $queryLinks;
        $fields = $this->dbo->qfields($fields, $this->fullTableName, $this->schema);
        if ($enableLinks) {
            // 当有关联需要处理时，必须获得主表的主键字段值
            $sql = "SELECT {$distinct} {$this->qpka}, {$fields} FROM {$this->qtableName} {$whereby} {$sortby}";
        } else {
            $sql = "SELECT {$distinct} {$fields} FROM {$this->qtableName} {$whereby} {$sortby}";
        }

        // 根据 $length 和 $offset 参数决定是否使用限定结果集的查询
        if (null !== $length || null !== $offset) {
            $result = $this->dbo->selectLimit($sql, $length, $offset);
        } else {
            $result = $this->dbo->execute($sql);
        }

        if ($enableLinks) {
            $pkvs = array();
            $assocRowset = null;
            $rowset = $this->dbo->getAllWithFieldRefs($result, $this->pka, $pkvs, $assocRowset);
            $in = 'IN (' . implode(',', array_map(array(& $this->dbo, 'qstr'), $pkvs)) . ')';
        } else {
            $rowset = $this->dbo->getAll($result);
        }
        unset($result);

        // 如果没有关联需要处理或者没有查询结果，则直接返回查询结果
        if (!$enableLinks || empty($rowset) || !$this->autoLink) {
            return $rowset;
        }

        $callback = create_function('& $r, $o, $m', '$r[$m] = null;');
        foreach ($this->links as $link) {
            /* @var $link FLEA_Db_TableLink */
            $mn = $link->mappingName;
            if (!$link->enabled || !$link->linkRead) { continue; }
            if (!$link->countOnly) {
                array_walk($assocRowset, $callback, $mn);
                $sql = $link->getFindSQL($in);
                $this->dbo->assemble($sql, $assocRowset, $mn, $link->oneToOne, $this->pka, $link->limit);
            } else {
                $link->calcCount($assocRowset, $mn, $in);
            }
        }

        return $rowset;
    }

    function assembleRecursionRow($mappingName, & $row, $enabledLinks = null)
    {
        $assoclink =& $this->getLink($mappingName);
        if ($assoclink == false) { return false; }

        $assoclink->init();
        $tdg =& $assoclink->assocTDG;
        $arow =& $row[$mappingName];

        if (!is_array($enabledLinks)) {
            if ($enabledLinks == null) {
                $enabledLinks = array_keys($tdg->links);
            } else {
                $enabledLinks = explode(',', $enabledLinks);
                array_walk($enabledLinks, 'trim');
                $enabledLinks = array_filter($enabledLinks, 'strlen');
            }
        }
        $enabledLinks = array_flip($enabledLinks);
        $enabledLinks = array_change_key_case($enabledLinks, CASE_LOWER);
        $this->enableLinks(array_keys($enabledLinks));

        foreach ($tdg->links as $link) {
            /* @var $link FLEA_Db_TableLink */
            if (!$link->enabled || !$link->linkRead || !isset($enabledLinks[$link->mappingName])) { continue; }

            $in = array();
            switch ($assoclink->type) {
            case HAS_ONE:
            case BELONGS_TO:
                $pkv = $arow[$link->mainTDG->primaryKey];
                $in[] = $pkv;
                $assocRowset = array($pkv => & $arow);
                $arow[$link->mappingName] = null;
                break;
            case HAS_MANY:
            case MANY_TO_MANY:
                $assocRowset = array();
                foreach (array_keys($arow) as $offset) {
                    $pkv = $arow[$offset][$link->mainTDG->primaryKey];
                    $in[] = $pkv;
                    $assocRowset[$pkv] = & $arow[$offset];
                    $arow[$offset][$link->mappingName] = null;
                }
            }
            $in = 'IN (' . implode(',', array_map(array(& $this->dbo, 'qstr'), $in)) . ')';

            $sql = $link->getFindSQL($in);
            $this->dbo->assemble($sql, $assocRowset, $link->mappingName, $link->oneToOne, $link->mainTDG->pka, $link->limit);
        }

        return true;
    }


    function assembleRecursionRowset($mappingName, & $rowset, $enabledLinks = null)
    {
        $assoclink =& $this->getLink($mappingName);
        if ($assoclink == false) { return false; }

        $assoclink->init();
        $tdg =& $assoclink->assocTDG;
        $arowset = array();
        foreach (array_keys($rowset) as $offset) {
            $arowset[] =& $rowset[$offset][$mappingName];
        }
        $keys = array_keys($arowset);

        if (!is_array($enabledLinks)) {
            if ($enabledLinks == null) {
                $enabledLinks = array_keys($tdg->links);
            } else {
                $enabledLinks = explode(',', $enabledLinks);
                array_walk($enabledLinks, 'trim');
                $enabledLinks = array_filter($enabledLinks, 'strlen');
            }
        }
        $enabledLinks = array_flip($enabledLinks);
        $enabledLinks = array_change_key_case($enabledLinks, CASE_LOWER);
        $this->enableLinks(array_keys($enabledLinks));

        foreach ($tdg->links as $link) {
            /* @var $link FLEA_Db_TableLink */
            if (!$link->enabled || !$link->linkRead || !isset($enabledLinks[$link->mappingName])) { continue; }

            $in = array();
            $assocRowset = array();
            switch ($assoclink->type) {
            case HAS_ONE:
            case BELONGS_TO:
                foreach ($keys as $key) {
                    $pkv = $arowset[$key][$link->mainTDG->primaryKey];
                    $in[] = $pkv;
                    $assocRowset[$pkv] =& $arowset[$key];
                    $arowset[$key][$link->mappingName] = null;
                }
                break;
            case HAS_MANY:
            case MANY_TO_MANY:
                foreach ($keys as $key) {
                    foreach (array_keys($arowset[$key]) as $offset) {
                        $pkv = $arowset[$key][$offset][$link->mainTDG->primaryKey];
                        $in[] = $pkv;
                        $assocRowset[$pkv] = & $arowset[$key][$offset];
                        $arow[$key][$offset][$link->mappingName] = null;
                    }
                }
            }
            $in = 'IN (' . implode(',', array_map(array(& $this->dbo, 'qstr'), $in)) . ')';

            $sql = $link->getFindSQL($in);
            $this->dbo->assemble($sql, $assocRowset, $link->mappingName, $link->oneToOne, $link->mainTDG->pka, $link->limit);
        }

        return true;
    }

    function & findByField($field, $value, $sort = null, $fields = '*')
    {
        return $this->find(array($field => $value), $sort, $fields);
    }

    function & findAllByField($field, $value, $sort = null, $limit = null, $fields = '*')
    {
        return $this->findAll(array($field => $value), $sort, $limit, $fields);
    }

    function & findAllByPkvs($pkvs, $conditions = null, $sort = null, $limit = null, $fields = '*', $queryLinks = true)
    {
        $in = array('in()' => $pkvs);
        if (empty($conditions)) {
            $conditions = $in;
        } else {
            if (!is_array($conditions)) {
                $conditions = array($in, $conditions);
            } else {
                array_push($conditions, $in);
            }
        }

        return $this->findAll($conditions, $sort, $limit, $fields, $queryLinks);
    }

    function & findBySql($sql, $limit = null)
    {
        // 处理 $limit
        if (is_array($limit)) {
            list($length, $offset) = $limit;
        } else {
            $length = $limit;
            $offset = null;
        }
        if (is_null($length) && is_null($offset)) {
            return $this->dbo->getAll($sql);
        }

        $result = $this->dbo->selectLimit($sql, $length, $offset);
        if ($result) {
            $rowset = $this->dbo->getAll($result);
        } else {
            $rowset = false;
        }
        return $rowset;
    }

    function findCount($conditions = null, $fields = null)
    {
        list($whereby, $distinct) = $this->getWhere($conditions);
        if (is_null($fields)) {
            $fields = $this->qpk;
        } else {
            $fields = $this->dbo->qfields($fields, $this->fullTableName);
        }
        $sql = "SELECT {$distinct}COUNT({$fields}) FROM {$this->qtableName}{$whereby}";
        return (int)$this->dbo->getOne($sql);
    }

    function save(& $row, $saveLinks = true, $updateCounter = true)
    {
        if (empty($row[$this->primaryKey])) {
            return $this->create($row, $saveLinks, $updateCounter);
        } else {
            return $this->update($row, $saveLinks, $updateCounter);
        }
    }

    function saveRowset(& $rowset, $saveLinks = true)
    {
        $this->dbo->startTrans();
        foreach ($rowset as $row) {
            if (!$this->save($row, $saveLinks, false)) {
                $this->dbo->completeTrans(false);
                return false;
            }
        }
        $this->dbo->completeTrans();
        return true;
    }

    function replace(& $row) {
        $this->_setCreatedTimeFields($row);
        $fields = '';
        $values = '';
        foreach ($row as $field => $value) {
            if (!isset($this->meta[strtoupper($field)])) { continue; }
            $fields .= $this->dbo->qfield($field) . ', ';
            $values .= $this->dbo->qstr($value) . ', ';
        }
        $fields = substr($fields, 0, -2);
        $values = substr($values, 0, -2);
        $sql = "REPLACE INTO {$this->fullTableName} ({$fields}) VALUES ({$values})";
        if (!$this->dbo->execute($sql)) { return false; }

        if (!empty($row[$this->primaryKey])) {
            return $row[$this->primaryKey];
        }

        $insertid = $this->dbo->insertId();
        return $insertid;
    }

    function replaceRowset(& $rowset)
    {
        $ids = array();
        $this->dbo->startTrans();
        foreach ($rowset as $row) {
            $id = $this->replace($row, false);
            if (!$id) {
                $this->dbo->completeTrans(false);
                return false;
            }
            $ids[] = $id;
        }
        $this->dbo->completeTrans();
        return $ids;
    }

    function update(& $row, $saveLinks = true)
    {
        if (!$this->_beforeUpdate($row)) {
            return false;
        }

        // 检查是否提供了主键值
        if (!isset($row[$this->primaryKey])) {
            FLEA::loadClass('FLEA_Db_Exception_MissingPrimaryKey');
            return __THROW(new FLEA_Db_Exception_MissingPrimaryKey($this->primaryKey));
        }

        // 自动填写记录的最后更新时间字段
        $this->_setUpdatedTimeFields($row);

        // 如果提供了验证器，则进行数据验证
        if ($this->autoValidating && $this->verifier != null) {
            if (!$this->checkRowData($row, true)) {
                // 验证失败抛出异常
                FLEA::loadClass('FLEA_Exception_ValidationFailed');
                return __THROW(new FLEA_Exception_ValidationFailed($this->getLastValidation(), $row));
            }
        }

        // 开始事务
        $this->dbo->startTrans();

        // 调用 _beforeUpdateDb() 事件
        if (!$this->_beforeUpdateDb($row)) {
            $this->dbo->completeTrans(false);
            return false;
        }

        // 生成 SQL 语句
        $pkv = $row[$this->primaryKey];
        unset($row[$this->primaryKey]);
        list($pairs, $values) = $this->dbo->getPlaceholderPair($row, $this->fields);
        $row[$this->primaryKey] = $pkv;

        if (!empty($pairs)) {
            $pairs = implode(',', $pairs);
            $sql = "UPDATE {$this->qtableName} SET {$pairs} WHERE {$this->qpk} = " . $this->dbo->qstr($pkv);

            // 执行更新操作
            if (!$this->dbo->execute($sql, $values)) {
                $this->dbo->completeTrans(false);
                return false;
            }
        }

        // 处理对关联数据的更新
        if ($this->autoLink && $saveLinks) {
            foreach (array_keys($this->links) as $linkKey) {
                $link =& $this->links[$linkKey];
                /* @var $link FLEA_Db_TableLink */
                // 跳过不需要处理的关联
                if (!$link->enabled || !$link->linkUpdate || !isset($row[$link->mappingName]) || !is_array($row[$link->mappingName])) {
                    continue;
                }

                if (!$link->saveAssocData($row[$link->mappingName], $pkv)) {
                    $this->dbo->completeTrans(false);
                    return false;
                }
            }
        }

        $this->_updateCounterCache($row);

        // 提交事务
        $this->dbo->completeTrans();

        $this->_afterUpdateDb($row);

        return true;
    }

    function updateRowset(& $rowset, $saveLinks = true)
    {
        $this->dbo->startTrans();
        foreach ($rowset as $row) {
            if (!$this->update($row, $saveLinks, false)) {
                $this->dbo->completeTrans(false);
                return false;
            }
        }
        $this->dbo->completeTrans();
        return true;
    }

    function updateByConditions($conditions, & $row)
    {
        $whereby = $this->getWhere($conditions, false);
        $this->_setUpdatedTimeFields($row);

        list($pairs, $values) = $this->dbo->getPlaceholderPair($row, $this->fields);
        $pairs = implode(',', $pairs);
        $sql = "UPDATE {$this->qtableName} SET {$pairs} {$whereby}";
        return $this->dbo->execute($sql, $values);
    }

    function updateField($conditions, $field, $value)
    {
        $row = array($field => $value);
        return $this->updateByConditions($conditions, $row);
    }

    function incrField($conditions, $field, $incr = 1)
    {
        $field = $this->dbo->qfield($field, $this->fullTableName, $this->schema);
        $incr = (int)$incr;

        $row = array();
        $this->_setUpdatedTimeFields($row);
        list($pairs, $values) = $this->dbo->getPlaceholderPair($row, $this->fields);
        $pairs = implode(',', $pairs);
        if ($pairs) {
            $pairs = ', ' . $pairs;
        }

        $whereby = $this->getWhere($conditions, false);
        $sql = "UPDATE {$this->qtableName} SET {$field} = {$field} + {$incr}{$pairs} {$whereby}";
        return $this->dbo->execute($sql, $values);
    }

    function decrField($conditions, $field, $decr = 1)
    {
        $field = $this->dbo->qfield($field, $this->fullTableName, $this->schema);
        $decr = (int)$decr;

        $row = array();
        $this->_setUpdatedTimeFields($row);
        list($pairs, $values) = $this->dbo->getPlaceholderPair($row, $this->fields);
        $pairs = implode(',', $pairs);
        if ($pairs) {
            $pairs = ', ' . $pairs;
        }

        $whereby = $this->getWhere($conditions, false);
        $sql = "UPDATE {$this->qtableName} SET {$field} = {$field}- {$decr}{$pairs} {$whereby}";
        return $this->dbo->execute($sql, $values);
    }

    function create(& $row, $saveLinks = true)
    {
        if (!$this->_beforeCreate($row)) {
            return false;
        }

        // 自动设置日期字段
        $this->_setCreatedTimeFields($row);

        // 处理主键
        $mpk = strtoupper($this->primaryKey);
        $insertId = null;
        $unsetpk = true;
        if (isset($this->meta[$mpk]['autoIncrement']) && $this->meta[$mpk]['autoIncrement'])
        {
            if (isset($row[$this->primaryKey])) {
                if (empty($row[$this->primaryKey])) {
                    // 如果主键字段是自增，而提供的记录数据虽然包含主键字段，
                    // 但却是空值，则删除这个空值
                    unset($row[$this->primaryKey]);
                } else {
                    $unsetpk = false;
                }
            }
        } else {
            // 如果主键字段不是自增字段，并且没有提供主键字段值时，则获取一个新的主键字段值
            if (!isset($row[$this->primaryKey]) || empty($row[$this->primaryKey])) {
                $insertId = $this->newInsertId();
                $row[$this->primaryKey] = $insertId;
            } else {
                // 使用开发者提交的主键字段值
                $insertId = $row[$this->primaryKey];
                $unsetpk = false;
            }
        }

        // 自动验证数据
        if ($this->autoValidating && $this->verifier != null) {
            if (!$this->checkRowData($row)) {
                FLEA::loadClass('FLEA_Exception_ValidationFailed');
                __THROW(new FLEA_Exception_ValidationFailed($this->getLastValidation(), $row));
                return false;
            }
        }

        // 调用 _beforeCreateDb() 事件
        $this->dbo->startTrans();

        if (!$this->_beforeCreateDb($row)) {
            if ($unsetpk) { unset($row[$this->primaryKey]); }
            $this->dbo->completeTrans(false);
            return false;
        }

        // 生成 SQL 语句
        list($holders, $values) = $this->dbo->getPlaceholder($row, $this->fields);
        $holders = implode(',', $holders);
        $fields = $this->dbo->qfields(array_keys($values));
        $sql = "INSERT INTO {$this->qtableName} ({$fields}) VALUES ({$holders})";

        // 插入数据
        if (!$this->dbo->Execute($sql, $values, true)) {
            if ($unsetpk) { unset($row[$this->primaryKey]); }
            $this->dbo->completeTrans(false);
            return false;
        }

        // 如果提交的数据中没有主键字段值，则尝试获取新插入记录的主键值
        if (is_null($insertId)) {
            $insertId = $this->dbo->insertId();
            if (!$insertId) {
                if ($unsetpk) { unset($row[$this->primaryKey]); }
                $this->dbo->completeTrans(false);
                FLEA::loadClass('FLEA_Db_Exception_InvalidInsertID');
                return __THROW(new FLEA_Db_Exception_InvalidInsertID());
            }
        }

        // 处理关联数据表
        if ($this->autoLink && $saveLinks) {
            foreach (array_keys($this->links) as $linkKey) {
                $link =& $this->links[$linkKey];
                /* @var $link FLEA_Db_TableLink */
                if (!$link->enabled || !$link->linkCreate || !isset($row[$link->mappingName]) || !is_array($row[$link->mappingName])) {
                    // 跳过没有关联数据的关联和不需要处理的关联
                    continue;
                }

                if (!$link->saveAssocData($row[$link->mappingName], $insertId)) {
                    if ($unsetpk) { unset($row[$this->primaryKey]); }
                    $this->dbo->completeTrans(false);
                    return false;
                }
            }
        }

        $row[$this->primaryKey] = $insertId;
        $this->_updateCounterCache($row);

        // 提交事务
        $this->dbo->CompleteTrans();

        $this->_afterCreateDb($row);
        if ($unsetpk) { unset($row[$this->primaryKey]); }

        return $insertId;
    }

    function createRowset(& $rowset, $saveLinks = true)
    {
        $insertids = array();
        $this->dbo->startTrans();
        foreach ($rowset as $row) {
            $insertid = $this->create($row, $saveLinks, false);
            if (!$insertid) {
                $this->dbo->completeTrans(false);
                return false;
            }
            $insertids[] = $insertid;
        }
        $this->dbo->completeTrans();
        return $insertids;
    }

    function remove(& $row)
    {
        if (!$this->_beforeRemove($row)) {
            return false;
        }

        if (!isset($row[$this->primaryKey])) {
            FLEA::loadClass('FLEA_Db_Exception_MissingPrimaryKey');
            __THROW(new FLEA_Db_Exception_MissingPrimaryKey($this->primaryKey));
            return false;
        }
        $ret = $this->removeByPkv($row[$this->primaryKey]);
        if ($ret) {
            $this->_afterRemoveDb($row);
        }
        return $ret;
    }

    function removeByPkv($pkv)
    {
        $this->dbo->startTrans();

        if (!$this->_beforeRemoveDbByPkv($pkv)) {
            $this->dbo->completeTrans(false);
            return false;
        }

        $qpkv = $this->dbo->qstr($pkv);

        // 处理关联数据表
        $counterCacheLinks = array();
        if ($this->autoLink) {
            foreach (array_keys($this->links) as $linkKey) {
                $link =& $this->links[$linkKey];
                /* @var $link FLEA_Db_TableLink */
                if (!$link->enabled) { continue; }
                switch ($link->type) {
                case MANY_TO_MANY:
                    /* @var $link FLEA_Db_ManyToManyLink */
                    if (!$link->deleteMiddleTableDataByMainForeignKey($qpkv)) {
                        $this->dbo->completeTrans(false);
                        return false;
                    }
                    break;
                case HAS_ONE:
                case HAS_MANY:
                    /* @var $link FLEA_Db_HasOneLink */
                    if ($link->deleteByForeignKey($qpkv) === false) {
                        $this->dbo->completeTrans(false);
                        return false;
                    }
                    break;
                case BELONGS_TO:
                    if ($link->counterCache) {
                        $counterCacheLinks[] = $link->foreignKey;
                    }
                }
            }
        }

        if (!empty($counterCacheLinks)) {
            $counterCacheLinks[] = $this->primaryKey;
            $row = $this->find(array($this->primaryKey => $pkv), null, $counterCacheLinks, false);
        }

        // 删除主表数据
        $sql = "DELETE FROM {$this->qtableName} WHERE {$this->qpk} = {$qpkv}";
        if ($this->dbo->execute($sql) == false) {
            $this->dbo->completeTrans(false);
            return false;
        }

        if (!empty($counterCacheLinks)) {
            $this->_updateCounterCache($row);
        }

        // 提交事务
        $this->dbo->completeTrans();

        $this->_afterRemoveDbByPkv($pkv);

        return true;
    }

    function removeByConditions($conditions)
    {
        $rowset = $this->findAll($conditions, null, null, $this->primaryKey, false);
        $count = 0;
        $this->dbo->startTrans();
        foreach ($rowset as $row) {
            if (!$this->removeByPkv($row[$this->primaryKey], false)) { break; }
            $count++;
        }
        $this->dbo->completeTrans();
        $rows = $this->dbo->affectedRows();
        if ($rows > 0) { return $count; }
        return 0;
    }

    function removeByPkvs($pkvs)
    {
        $ret = true;
        $this->dbo->startTrans();
        foreach ($pkvs as $id) {
            $ret = $this->removeByPkv($id, false);
            if ($ret === false) { break; }
        }
        $this->dbo->completeTrans();
        return $ret;
    }

    function removeAll()
    {
        $sql = "DELETE FROM {$this->qtableName}";
        $ret = $this->execute($sql);
        return $ret;
    }

    function removeAllWithLinks()
    {
        $this->dbo->startTrans();

        // 处理关联数据表
        if ($this->autoLink) {
            foreach (array_keys($this->links) as $linkKey) {
                $link =& $this->links[$linkKey];
                /* @var $link FLEA_Db_TableLink */
                switch ($link->type) {
                case MANY_TO_MANY:
                    /* @var $link FLEA_Db_ManyToManyLink */
                    $link->init();
                    $sql = "DELETE FROM {$link->qjoinTable}";
                    break;
                case HAS_ONE:
                case HAS_MANY:
                    $link->init();
                    $sql = "DELETE FROM {$link->assocTDG->qtableName}";
                    break;
                default:
                    continue;
                }
                if ($this->dbo->execute($sql) == false) {
                    $this->dbo->completeTrans(false);
                    return false;
                }
            }
        }

        $sql = "DELETE FROM {$this->qtableName}";
        if ($this->dbo->execute($sql) == false) {
            $this->dbo->completeTrans(false);
            return false;
        }

        // 提交事务
        $this->dbo->completeTrans();

        return true;
    }

    function enableLinks($links = null)
    {
        $this->autoLink = true;
        if (is_null($links)) {
            $links = array_keys($this->links);
        } elseif (!is_array($links)) {
            $links = explode(',', $links);
            $links = array_filter(array_map('trim', $links), 'strlen');
        }

        foreach ($links as $name) {
            $name = strtoupper($name);
            if (isset($this->links[$name])) {
                $this->links[$name]->enabled = true;
            }
        }
    }

    function enableLink($linkName)
    {
        $link =& $this->getLink($linkName);
        if ($link) { $link->enabled = true; }
        $this->autoLink = true;
        return $link;
    }

    function disableLinks($links = null)
    {
        if (is_null($links)) {
            $links = array_keys($this->links);
            $this->autoLink = false;
        } elseif (!is_array($links)) {
            $links = explode(',', $links);
            $links = array_filter(array_map('trim', $links), 'strlen');
        }

        foreach ($links as $name) {
            $name = strtoupper($name);
            if (isset($this->links[$name])) {
                $this->links[$name]->enabled = false;
            }
        }
    }

    function disableLink($linkName)
    {
        $link =& $this->getLink($linkName);
        if ($link) { $link->enabled = false; }
        return $link;
    }

    function clearLinks()
    {
        $this->links = array();
    }

    function relink()
    {
        $this->clearLinks();
        $this->createLink($this->hasOne,     HAS_ONE);
        $this->createLink($this->belongsTo,  BELONGS_TO);
        $this->createLink($this->hasMany,    HAS_MANY);
        $this->createLink($this->manyToMany, MANY_TO_MANY);
    }

    function & getLink($linkName)
    {
        $linkName = strtoupper($linkName);
        if (isset($this->links[$linkName])) {
            return $this->links[$linkName];
        }

        FLEA::loadClass('FLEA_Db_Exception_MissingLink');
        __THROW(new FLEA_Db_Exception_MissingLink($linkName));
        $ret = false;
        return $ret;
    }

    function & getLinkTable($linkName)
    {
        $link =& $this->getLink($linkName);
        $link->init();
        return $link->assocTDG;
    }

    function & existsLink($name)
    {
        $name = strtoupper($name);
        return isset($this->links[$name]);
    }

    function createLink($defines, $type)
    {
        if (!is_array($defines)) { return; }
        if (!is_array(reset($defines))) {
            $defines = array($defines);
        }

        // 创建关联对象
        foreach ($defines as $define) {
            if (!is_array($define)) { continue; }
            // 构造连接对象实例
            $link =& FLEA_Db_TableLink::createLink($define, $type, $this);
            $this->links[strtoupper($link->name)] =& $link;
        }
    }

    function removeLink($linkName)
    {
        $linkName = strtoupper($linkName);
        if (isset($this->links[$linkName])) {
            unset($this->links[$linkName]);
        }
    }

    function checkRowData(& $row, $skip = 0) {
        if (is_null($this->verifier)) { return false; }
        $this->lastValidationResult = $this->verifier->checkAll($row, $this->meta, $skip);
        return empty($this->lastValidationResult);
    }

    function getLastValidation($info = null) {
        if (is_null($info)) { return $this->lastValidationResult; }

        $arr = array();
        foreach ($this->lastValidationResult as $field => $check) {
            if (empty($check['rule'][$info])) {
                $arr[] = $field;
            } else {
                $arr[] = $check['rule'][$info];
            }
        }
        return $arr;
    }

    function newInsertId() {
        return $this->dbo->nextId($this->fullTableName . '_seq');
    }

    function execute($sql, $inputarr = false)
    {
        return $this->dbo->execute($sql, $inputarr);
    }

    function qinto($sql, $params = null)
    {
        if (!is_array($params)) {
            FLEA::loadClass('FLEA_Exception_TypeMismatch');
            return __THROW(new FLEA_Exception_TypeMismatch('$params', 'array', gettype($params)));
        }
        $arr = explode('?', $sql);
        $sql = array_shift($arr);
        foreach ($params as $value) {
            $sql .= $this->dbo->qstr($value) . array_shift($arr);
        }
        return $sql;
    }
    
    function parseWhere($where, $args = null)
    {
        if (!is_array($args)) {
            $args = array();
        }
        if (is_array($where)) {
            return $this->_parseWhereArray($where);
        } else {
            return $this->_parseWhereString($where, $args);
        }
    }
    
    function _parseWhereArray($where)
    {
        $parts = array();
        $callback = array($this->dbo, 'qstr');
        $next_op = '';

        foreach ($where as $key => $value) {
            if (is_int($key)) {
                $parts[] = $value;
                if ($value == ')') {
                    $next_op = 'AND';
                } else {
                    $next_op = '';
                }
            } else {
                if ($next_op != '') {
                    $parts[] = $next_op;
                }
                $field = $this->_parseWhereQfield(array('', $key));
                if (is_array($value)) {
                    $value = array_map($callback, $value);
                    $parts[] = $field . ' IN (' . implode(',', $value) . ')';
                } else {
                    $value = $this->dbo->qstr($value);
                    $parts[] = $field . ' = ' . $value;
                }
                $next_op = 'AND';
            }
        }

        return implode(' ', $parts);
    }
    
    function _parseWhereString($where, $args = null)
    {
        // 首先从查询条件中提取出可以识别的字段名
        if (strpos($where, '[') !== false) {
            // 提取字段名
            $where = preg_replace_callback('/\[([a-z0-9_\-\.]+)\]/i', array($this, '_parseWhereQfield'), $where);
        }
        
        return $this->qinto($where, $args);
    }

    function _parseWhereQfield($matches)
    {
        $p = explode('.', $matches[1]);
        switch (count($p)) {
        case 3:
            list($schema, $table, $field) = $p;
            if ($table == $this->tableName) {
                $table = $this->fullTableName;
            }
            return $this->dbo->qfield($field, $table, $schema);
        case 2:
            list($table, $field) = $p;
            if ($table == $this->tableName) {
                $table = $this->fullTableName;
            }
            return $this->dbo->qfield($field, $table);
        default:
            return $this->dbo->qfield($p[0]);
        }
    }

    function qstr($value)
    {
        return $this->dbo->qstr($value);
    }

    function qfield($fieldName, $tableName = null)
    {
        if (is_null($tableName)) {
            $tableName = $this->fullTableName;
        }
        return $this->dbo->qfield($fieldName, $tableName, $this->schema);
    }

    function qfields($fieldsName, $tableName = null, $returnArray = false)
    {
        if (is_null($tableName)) {
            $tableName = $this->fullTableName;
        }
        return $this->dbo->qfields($fieldsName, $tableName, $this->schema, $returnArray);
    }

    function getWhere($conditions, $queryLinks = true) {
        // 处理查询条件
        $where = FLEA_Db_SqlHelper::parseConditions($conditions, $this);
        $sqljoin = '';
        $distinct = '';

        do {
            if (!is_array($where)) {
                $whereby = $where != '' ? " WHERE {$where}" : '';
                break;
            }

            $arr = $where;