Yii源码阅读笔记

概述

Yii中，对Model层的使用，有两种方式：

通过类CDbConnection和CDbCommand来操作
使用ORM形式：编写model类继承自抽象类CActiveRecord

第1种方式的示例如下：

<?php
$connection = Yii::app()->db;  // 或者Yii::app()->getComponent('db');
$queryResult = $connection->createCommand($sql)->queryRow();

第2种方式中编写的model类可能需要实现方法getDbConnection、model、tableName。

在实现上，第2种方式是基于第1种方式的，即第2种方式的抽象程度更高。Yii没有屏蔽第1种方式，这样能让开发者按需选择。但我个人并不喜欢这样，两种方式同时存在，会导致应用的model实现稍显混乱。

分析

Yii框架model层的入口为CDbConnection类，该类有很多public的属性可供配置，如connectionString、username、password等。

根据Yii源码阅读笔记 - 组件集成一文可知，组件初始化时会调用init方法。类CDbConnection的init类实现如下：

public function init()
{
    parent::init();
    // 属性autoConnect默认为true
    if($this->autoConnect)
        $this->setActive(true);
}

其中调用的setActive方法实现如下：

public function setActive($value)
{
    // 当$value为true，而_active为false（表示数据库连接未打开），则打开数据库连接
    // 当$value为false, 而_active为true（表示数据库连接已打开），则关闭数据库连接
    if($value!=$this->_active)
    {
        if($value)
            $this->open();
        else
            $this->close();
    }
}

方法open实现如下：

/**
 * Opens DB connection if it is currently not
 * @throws CException if connection fails
 */
protected function open()
{
    if($this->_pdo===null)
    {
        // 所以需要配置connectionString
        if(empty($this->connectionString))
            throw new CDbException('CDbConnection.connectionString cannot be empty.');
        try
        {
            Yii::trace('Opening DB connection','system.db.CDbConnection');
            // 基于PDO类建立数据库连接（对于某些数据库不使用PDO）
            $this->_pdo=$this->createPdoInstance();
            // 设置数据库连接的一些属性，如字符编码等
            $this->initConnection($this->_pdo);
            // 标志位设置为已打开
            $this->_active=true;
        }
        catch(PDOException $e)
        {
            // 省略
        }
    }
}

方法close实现如下：

/**
 * Closes the currently active DB connection.
 * It does nothing if the connection is already closed.
 */
protected function close()
{
    Yii::trace('Closing DB connection','system.db.CDbConnection');
    $this->_pdo=null;
    $this->_active=false;
    $this->_schema=null;
}

open方法中调用的方法createPdoInstance实现如下：

/**
 * Creates the PDO instance.
 * When some functionalities are missing in the pdo driver, we may use
 * an adapter class to provide them.
 * @throws CDbException when failed to open DB connection
 * @return PDO the pdo instance
 */
protected function createPdoInstance()
{
    // 属性pdoClass默认为PDO
    $pdoClass=$this->pdoClass;
    if(($pos=strpos($this->connectionString,':'))!==false)
    {
        // 取出数据库驱动类型
        $driver=strtolower(substr($this->connectionString,0,$pos));
        if($driver==='mssql' || $driver==='dblib')
            $pdoClass='CMssqlPdoAdapter';
        elseif($driver==='sqlsrv')
            $pdoClass='CMssqlSqlsrvPdoAdapter';
    }

    if(!class_exists($pdoClass))
        throw new CDbException(Yii::t('yii','CDbConnection is unable to find PDO class "{className}". Make sure PDO is installed correctly.',
            array('{className}'=>$pdoClass)));

    // 实例化类PDO，可能失败
    @$instance=new $pdoClass($this->connectionString,$this->username,$this->password,$this->_attributes);

    if(!$instance)
        throw new CDbException(Yii::t('yii','CDbConnection failed to open the DB connection.'));

    return $instance;
}

从中可以看出，对于MySQL数据库而言，方法createPdoInstance返回的是一个PDO对象，赋值给CDbConnection对象的_pdo属性。

方法initConnection的实现如下：

/**
 * Initializes the open db connection.
 * This method is invoked right after the db connection is established.
 * The default implementation is to set the charset for MySQL and PostgreSQL database connections.
 * @param PDO $pdo the PDO instance
 */
protected function initConnection($pdo)
{
    // 设置数据库连接的一些属性
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    if($this->emulatePrepare!==null && constant('PDO::ATTR_EMULATE_PREPARES'))
        $pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES,$this->emulatePrepare);
    if($this->charset!==null)
    {
        $driver=strtolower($pdo->getAttribute(PDO::ATTR_DRIVER_NAME));
        if(in_array($driver,array('pgsql','mysql','mysqli')))
            $pdo->exec('SET NAMES '.$pdo->quote($this->charset));
    }
    // 执行一些初始化的SQL语句
    // public $initSQLs : array list of SQL statements that should be executed right after the DB connection is established.
    if($this->initSQLs!==null)
    {
        foreach($this->initSQLs as $sql)
            $pdo->exec($sql);
    }
}

由于第2种方式是基于第1中方式实现的，所以我们先看看第1种方式的实现。

类CDbConnection中方法createCommand的实现如下：

public function createCommand($query=null)
{
    $this->setActive(true);
    return new CDbCommand($this,$query);
}

其中实例化的类CDbCommand的构造方法实现如下：

/**
 * Constructor.
 * @param CDbConnection $connection the database connection
 * @param mixed $query the DB query to be executed. This can be either
 * a string representing a SQL statement, or an array whose name-value pairs
 * will be used to set the corresponding properties of the created command object.
 *
 * For example, you can pass in either <code>'SELECT * FROM tbl_user'</code>
 * or <code>array('select'=>'*', 'from'=>'tbl_user')</code>. They are equivalent
 * in terms of the final query result.
 *
 * When passing the query as an array, the following properties are commonly set:
 * {@link select}, {@link distinct}, {@link from}, {@link where}, {@link join},
 * {@link group}, {@link having}, {@link order}, {@link limit}, {@link offset} and
 * {@link union}. Please refer to the setter of each of these properties for details
 * about valid property values. This feature has been available since version 1.1.6.
 *
 * Since 1.1.7 it is possible to use a specific mode of data fetching by setting
 * {@link setFetchMode FetchMode}. See {@link http://www.php.net/manual/en/function.PDOStatement-setFetchMode.php}
 * for more details.
 */
public function __construct(CDbConnection $connection,$query=null)
{
    $this->_connection=$connection;
    if(is_array($query))
    {
        foreach($query as $name=>$value)
            $this->$name=$value;
    }
    else
        $this->setText($query);
}

可以看到参数$query并不是必须提供，如果提供，则$query参数值可以是字符串也可以是数组。如果是字符串也就是一个原生的SQL语句（可能有参数需要填充），如果是数组，则可以为CDbCommand对象的select、distinct、from等属性赋值。

方法setText实现如下：

/**
 * Specifies the SQL statement to be executed.
 * Any previous execution will be terminated or cancel.
 * @param string $value the SQL statement to be executed
 * @return CDbCommand this command instance
 */
public function setText($value)
{
    if($this->_connection->tablePrefix!==null && $value!='')
        $this->_text=preg_replace('/{{(.*?)}}/',$this->_connection->tablePrefix.'1',$value);
    else
        $this->_text=$value;
    // 因为是要新执行一条语句，所以需要重置状态，将属性_statement置为null。
    $this->cancel();
    return $this;
}

如果调用类CDbConnection的createCommand方法时提供了$query参数值，则在得到CDbCommand对象后，即可调用CDbCommand对象的execute方法（对于增、删、改操作）或query、queryAll、queryRow等方法（对于查询操作）来执行数据库操作。

如果调用createCommand时未提供$query参数值，则有3种方式来完成数据库操作：

对于普通的数据库查询操作，得到CDbCommand对象后，链式调用方法select、from、where等（之所以能够链式调用，是因为这些方法的最后都返回了对象本身），并且链式调用的最后调用query一类方法来执行数据库操作。
对于会对数据表结构或数据产生变更的操作，得到CDbCommand对象后，可以直接调用方法insert、update、delete、createTable等来执行操作。
可以在得到CDbCommand对象后，调用方法setText来设置待执行的SQL语句，setText方法的$value参数类型应为字符串。如果调用setText方法前$value参数类型是关联数组，则可以先调用方法buildQuery从关联数组生成一个SQL语句字符串，再调用setText方法；或者直接调用setSelect、setFrom、setWhere等方法来设置SQL语句的各个组成部分。最后调用execute方法或query一类方法。可以看出相比传递$query参数，这种方式只不过是显式地设置SQL语句。通常这是不推荐的（搞这么麻烦，何必呢？呵呵）。

这样一看，类CDbCommand的实现稍显混乱。本意上额外的第3种方式应该是提供给类CActiveRecord使用的，所以不建议使用。

接下来看看方法execute方法及query一类（仅以方法query、queryAll为例）方法的实现：

/**
 * Executes the SQL statement.
 * This method is meant only for executing non-query SQL statement.
 * No result set will be returned.
 * @param array $params input parameters (name=>value) for the SQL execution. This is an alternative
 * to {@link bindParam} and {@link bindValue}. If you have multiple input parameters, passing
 * them in this way can improve the performance. Note that if you pass parameters in this way,
 * you cannot bind parameters or values using {@link bindParam} or {@link bindValue}, and vice versa.
 * Please also note that all values are treated as strings in this case, if you need them to be handled as
 * their real data types, you have to use {@link bindParam} or {@link bindValue} instead.
 * @return integer number of rows affected by the execution.
 * @throws CDbException execution failed
 */
public function execute($params=array())
{
    if($this->_connection->enableParamLogging && ($pars=array_merge($this->_paramLog,$params))!==array())
    {
        $p=array();
        foreach($pars as $name=>$value)
            $p[$name]=$name.'='.var_export($value,true);
        $par='. Bound with ' .implode(', ',$p);
    }
    else
        $par='';
    Yii::trace('Executing SQL: '.$this->getText().$par,'system.db.CDbCommand');
    try
    {
        if($this->_connection->enableProfiling)
            Yii::beginProfile('system.db.CDbCommand.execute('.$this->getText().$par.')','system.db.CDbCommand.execute');

        // 以通过setText设置的SQL语句为参数间接调用PDO对象的prepare方法，并将返回的PDOStatement对象赋值给当前CDbCommand对象的_statement属性。
        $this->prepare();
        if($params===array())
            // 无参执行
            $this->_statement->execute();
        else
            // 带参执行
            $this->_statement->execute($params);
        // 操作影响的数据表行数
        $n=$this->_statement->rowCount();

        if($this->_connection->enableProfiling)
            Yii::endProfile('system.db.CDbCommand.execute('.$this->getText().$par.')','system.db.CDbCommand.execute');

        return $n;
    }
    catch(Exception $e)
    {
        // 省略
    }
}

public function query($params=array())
{
    return $this->queryInternal('',0,$params);
}

public function queryAll($fetchAssociative=true,$params=array())
{
    return $this->queryInternal('fetchAll',$fetchAssociative ? $this->_fetchMode : PDO::FETCH_NUM, $params);
}

可以看到query一类方法都是间接调用方法queryInternal来完成操作的。queryInternal方法实现如下：

private function queryInternal($method,$mode,$params=array())
{
    $params=array_merge($this->params,$params);

    if($this->_connection->enableParamLogging && ($pars=array_merge($this->_paramLog,$params))!==array())
    {
        $p=array();
        foreach($pars as $name=>$value)
            $p[$name]=$name.'='.var_export($value,true);
        $par='. Bound with '.implode(', ',$p);
    }
    else
        $par='';

    Yii::trace('Querying SQL: '.$this->getText().$par,'system.db.CDbCommand');

    // 先尝试从缓存中读取查询结果
    // 这里涉及CDbConnection类的三个属性queryCachingCount、queryCachingDuration、queryCacheID
    // 另外对于方法query（调用queryInternal时提供的method参数为空字符串）的操作不会缓存
    if($this->_connection->queryCachingCount>0 && $method!==''
            && $this->_connection->queryCachingDuration>0
            && $this->_connection->queryCacheID!==false
            && ($cache=Yii::app()->getComponent($this->_connection->queryCacheID))!==null)
    {
        $this->_connection->queryCachingCount--;
        $cacheKey='yii:dbquery'.$this->_connection->connectionString.':'.$this->_connection->username;
        $cacheKey.=':'.$this->getText().':'.serialize(array_merge($this->_paramLog,$params));
        if(($result=$cache->get($cacheKey))!==false)
        {
            Yii::trace('Query result found in cache','system.db.CDbCommand');
            return $result[0];
        }
    }

    try
    {
        if($this->_connection->enableProfiling)
            Yii::beginProfile('system.db.CDbCommand.query('.$this->getText().$par.')','system.db.CDbCommand.query');

        $this->prepare();
        if($params===array())
            $this->_statement->execute();
        else
            $this->_statement->execute($params);

        // $method对应PDOStatement的结果获取方法，如果未提供$method，自然无法直接通过PDOStatement获取查询结果。
        if($method==='')
            // 这个细看一下
            $result=new CDbDataReader($this);
        else
        {
            $mode=(array)$mode;
            call_user_func_array(array($this->_statement, 'setFetchMode'), $mode);
            // 调用PDOStatement对应的方法
            $result=$this->_statement->$method();
            $this->_statement->closeCursor();
        }

        if($this->_connection->enableProfiling)
            Yii::endProfile('system.db.CDbCommand.query('.$this->getText().$par.')','system.db.CDbCommand.query');

        // 如果设置了$cache和$cacheKey
        // 将查询结果存入缓存
        if(isset($cache,$cacheKey))
            $cache->set($cacheKey, array($result), $this->_connection->queryCachingDuration, $this->_connection->queryCachingDependency);

        return $result;
    }
    catch(Exception $e)
    {
        // 省略
    }
}

可以看到query方法调用queryInternal时，结果是通过CDbDataReader对象来获取的。类CDbDataReader的构造方法实现如下：

public function __construct(CDbCommand $command)
{
    $this->_statement=$command->getPdoStatement();
    $this->_statement->setFetchMode(PDO::FETCH_ASSOC);
}

得到CDbDataReader对象，即可通过它的read一类方法迭代获取查询结果。这些方法实际上是调用PDOStatement的fetch一类方法来获取结果的。

再来看看Yii框架Model层的第2种使用方式。

CActiveRecord的用法是，对于数据库的每个数据表，创建一个model类，如UserModel，这个类继承自CActiveRecord类。model类名可以和数据表名一致，也可以不一致，如果不一致，则需要重写CActiveRecord类的tableName方法，标明该model类对应的数据表名。方法tableName默认的实现如下：

/**
* Returns the name of the associated database table.
* By default this method returns the class name as the table name.
* You may override this method if the table is not named after this convention.
* @return string the table name
*/
public function tableName()
{
    return get_class($this);
}

假设UserModel类对应的数据表名为User，则应如下重写tableName：

public function tableName()
{
    return 'User';
}

使用CActiveRecord方式，若想向数据表中插入一条新纪录，则需要实例化当前model类。以UserModel类为例，若想向User表中插入一条新纪录，则需要先实例化UserModel，得到一个对象，然后对该对象的属性进行赋值指明对应数据表新记录每个字段的值。对象的属性名即数据表的字段名，赋值完毕，调用save或insert即向数据表中存入该新纪录。

CActiveRecord类的构造方法如下所示：

public function __construct($scenario='insert')
{
    if($scenario===null) // internally used by populateRecord() and model()
        return;

    $this->setScenario($scenario);
    $this->setIsNewRecord(true);
    $this->_attributes=$this->getMetaData()->attributeDefaults;

    $this->init();

    $this->attachBehaviors($this->behaviors());
    $this->afterConstruct();
}

$scenario='insert'，表示新实例化的对象处于待插入数据表的状态，在调用save等方法时，会检测该状态。在新实例化的对象插入到数据表后，该状态立即会变为"update"，表示之后对该对象的数据库写入操作，属于update操作。

CActiveRecord类的save方法的实现如下：

public function save($runValidation=true,$attributes=null)
{
    // 若需要则对某些属性做校验
    if(!$runValidation || $this->validate($attributes))
        // 如果是新纪录，则插入，否则更新
        return $this->getIsNewRecord() ? $this->insert($attributes) : $this->update($attributes);
    else
        return false;
}

而insert、update方法的实现如下所示：

public function insert($attributes=null)
{
    if(!$this->getIsNewRecord())
        throw new CDbException(Yii::t('yii','The active record cannot be inserted to database because it is not new.'));
    if($this->beforeSave())
    {
        Yii::trace(get_class($this).'.insert()','system.db.ar.CActiveRecord');
        // ...
        $builder=$this->getCommandBuilder();
        // ...
        $table=$this->getMetaData()->tableSchema;
        $command=$builder->createInsertCommand($table,$this->getAttributes($attributes));
        if($command->execute())
        {
            $primaryKey=$table->primaryKey;
            if($table->sequenceName!==null)
            {
                if(is_string($primaryKey) && $this->$primaryKey===null)
                    $this->$primaryKey=$builder->getLastInsertID($table);
                elseif(is_array($primaryKey))
                {
                    foreach($primaryKey as $pk)
                    {
                        if($this->$pk===null)
                        {
                            $this->$pk=$builder->getLastInsertID($table);
                            break;
                        }
                    }
                }
            }
            $this->_pk=$this->getPrimaryKey();
            $this->afterSave();
            $this->setIsNewRecord(false);
            $this->setScenario('update');
            return true;
        }
    }
    return false;
}

public function update($attributes=null)
{
    if($this->getIsNewRecord())
        throw new CDbException(Yii::t('yii','The active record cannot be updated because it is new.'));
    if($this->beforeSave())
    {
        Yii::trace(get_class($this).'.update()','system.db.ar.CActiveRecord');
        if($this->_pk===null)
            $this->_pk=$this->getPrimaryKey();
        // 间接调用updateByPk来完成操作
        $this->updateByPk($this->getOldPrimaryKey(),$this->getAttributes($attributes));
        $this->_pk=$this->getPrimaryKey();
        $this->afterSave();
        return true;
    }
    else
        return false;
}

insert方法中调用的getCommandBuilder方法实现如下：

public function getCommandBuilder()
{
    return $this->getDbConnection()->getSchema()->getCommandBuilder();
}

其中getDbConnection方法实现如下：

public function getDbConnection()
{
    if(self::$db!==null)
        return self::$db;
    else
    {
        self::$db=Yii::app()->getDb();
        if(self::$db instanceof CDbConnection)
            return self::$db;
        else
            throw new CDbException(Yii::t('yii','Active Record requires a "db" CDbConnection application component.'));
    }
}

Yii中默认的DB组件名为db，所以如果你使用的是默认的db数据库，那么不用重写这个方法。否则，需要重写该方法，指明需要使用的数据库连接。

getDbConnection方法返回的是一个CDbConnection对象，其getSchema方法实现如下：

public function getSchema()
{
    if($this->_schema!==null)
        return $this->_schema;
    else
    {
        // 返回数据库配置信息connectionString字段中的数据库驱动类型，如mysql
        $driver=$this->getDriverName();
        /*
            driverMap属性的定义：
            public $driverMap=array(
              'pgsql'=>'CPgsqlSchema',    // PostgreSQL
              'mysqli'=>'CMysqlSchema',   // MySQL
              'mysql'=>'CMysqlSchema',    // MySQL
              'sqlite'=>'CSqliteSchema',  // sqlite 3
              'sqlite2'=>'CSqliteSchema', // sqlite 2
              'mssql'=>'CMssqlSchema',    // Mssql driver on windows hosts
              'dblib'=>'CMssqlSchema',    // dblib drivers on linux (and maybe others os) hosts
              'sqlsrv'=>'CMssqlSchema',   // Mssql
              'oci'=>'COciSchema',        // Oracle driver
           );
        */
        if(isset($this->driverMap[$driver]))
            // 加载对应的数据库驱动组件
            return $this->_schema=Yii::createComponent($this->driverMap[$driver], $this);
        else
            throw new CDbException(Yii::t('yii','CDbConnection does not support reading schema for {driver} database.',
                array('{driver}'=>$driver)));
    }
}

以mysql的CMysqlSchema为例，Yii::createComponent($this->driverMap[$driver], $this)一句会实例化yii/framework/db/schema/mysql/CMysqlSchema.php中定义的CMysqlSchema类。该类自身无构造方法，继承自抽象类CDbSchema，CDbSchema的构造方法实现如下：

public function __construct($conn)
{
    // 保存着当前CDbConnection数据库连接对象
    $this->_connection=$conn;
    foreach($conn->schemaCachingExclude as $name)
        $this->_cacheExclude[$name]=true;
}

得到CMysqlSchema对象后，调用其getCommandBuilder方法，该方法定义于类CDbSchema中，实现如下：

public function getCommandBuilder()
{
    if($this->_builder!==null)
        return $this->_builder;
    else
        return $this->_builder=$this->createCommandBuilder();
}

其中调用的方法createCommandBuilder实现如下：

protected function createCommandBuilder()
{
    return new CDbCommandBuilder($this);
}

实例化的CDbCommandBuilder类的构造方法如下所示：

public function __construct($schema)
{
    $this->_schema=$schema;
    $this->_connection=$schema->getDbConnection();
}

这样insert方法中调用的getCommandBuilder最终返回了一个CDbCommandBuilder对象。

而insert方法中$table=$this->getMetaData()->tableSchema一句调用的getMetaData方法实现如下：

public function getMetaData()
{
    $className=get_class($this);
    if(!array_key_exists($className,self::$_md))
    {
        self::$_md[$className]=null; // preventing recursive invokes of {@link getMetaData()} via {@link __get()}
        self::$_md[$className]=new CActiveRecordMetaData($this);
    }
    return self::$_md[$className];
}

其中实例化的类CActiveRecordMetaData，构造方法如下所示：

public function __construct($model)
{
    // 当前model类名
    $this->_modelClassName=get_class($model);

    // 得到表名
    $tableName=$model->tableName();

    // 调用_schema（以mysql为例，其值为CMysqlSchema对象）的getTable方法
    if(($table=$model->getDbConnection()->getSchema()->getTable($tableName))===null)
        throw new CDbException(Yii::t('yii','The table "{table}" for active record class "{class}" cannot be found in the database.',
            array('{class}'=>$this->_modelClassName,'{table}'=>$tableName)));
    if($table->primaryKey===null)
    {
        $table->primaryKey=$model->primaryKey();
        if(is_string($table->primaryKey) && isset($table->columns[$table->primaryKey]))
            $table->columns[$table->primaryKey]->isPrimaryKey=true;
        elseif(is_array($table->primaryKey))
        {
            foreach($table->primaryKey as $name)
            {
                if(isset($table->columns[$name]))
                    $table->columns[$name]->isPrimaryKey=true;
            }
        }
    }
    // 将数据表结构信息存于属性tableSchema
    $this->tableSchema=$table;
    $this->columns=$table->columns;

    foreach($table->columns as $name=>$column)
    {
        if(!$column->isPrimaryKey && $column->defaultValue!==null)
            $this->attributeDefaults[$name]=$column->defaultValue;
    }

    foreach($model->relations() as $name=>$config)
    {
        $this->addRelation($name,$config);
    }
}

其中调用的getTable方法，定义于抽象类CDbSchema中，实现如下：

public function getTable($name,$refresh=false)
{
    if($refresh===false && isset($this->_tables[$name]))
        return $this->_tables[$name];
    else
    {
        if($this->_connection->tablePrefix!==null && strpos($name,'{{')!==false)
            $realName=preg_replace('/{{(.*?)}}/',$this->_connection->tablePrefix.'$1',$name);
        else
            $realName=$name;

        // temporarily disable query caching
        if($this->_connection->queryCachingDuration>0)
        {
            $qcDuration=$this->_connection->queryCachingDuration;
            $this->_connection->queryCachingDuration=0;
        }

        // 先尝试从缓存中取数据表结构信息
        // CDbConnection类的schemaCachingDuration属性默认为0，如果不配置该属性，那么就不会使用缓存，那么每次增、删、改、查操作都需要loadTable，
        // 对数据库的压力，以及性能影响是不是很大？！但如果加了缓存，那么当对数据表的结构做变更时会不会有问题？
        if(!isset($this->_cacheExclude[$name]) && ($duration=$this->_connection->schemaCachingDuration)>0 && $this->_connection->schemaCacheID!==false && ($cache=Yii::app()->getComponent($this->_connection->schemaCacheID))!==null)
        {
            $key='yii:dbschema'.$this->_connection->connectionString.':'.$this->_connection->username.':'.$name;
            $table=$cache->get($key);
            // 没取到或者需要刷新缓存，则从数据库获取，并更新缓存
            if($refresh===true || $table===false)
            {
                $table=$this->loadTable($realName);
                if($table!==null)
                    $cache->set($key,$table,$duration);
            }
            $this->_tables[$name]=$table;
        }
        else
            // 直接从数据库获取数据表结构信息
            $this->_tables[$name]=$table=$this->loadTable($realName);

        if(isset($qcDuration))  // re-enable query caching
            $this->_connection->queryCachingDuration=$qcDuration;

        return $table;
    }
}

其中调用的loadTable方法最终是通过执行SQL语句：

'SHOW FULL COLUMNS FROM '.$table->rawName
'SHOW CREATE TABLE '.$table->rawName

来获取数据表信息，并将信息存于一个CMysqlColumnSchema对象中（以mysql为例）。

insert方法中$command=$builder->createInsertCommand($table,$this->getAttributes($attributes))一句createInsertCommand方法定义于CDbCommandBuilder类中，实现如下：

public function createInsertCommand($table,$data)
{
    $this->ensureTable($table);
    $fields=array();
    $values=array();
    $placeholders=array();
    $i=0;
    foreach($data as $name=>$value)
    {
        if(($column=$table->getColumn($name))!==null && ($value!==null || $column->allowNull))
        {
            $fields[]=$column->rawName;
            if($value instanceof CDbExpression)
            {
                $placeholders[]=$value->expression;
                foreach($value->params as $n=>$v)
                    $values[$n]=$v;
            }
            else
            {
                $placeholders[]=self::PARAM_PREFIX.$i;
                $values[self::PARAM_PREFIX.$i]=$column->typecast($value);
                $i++;
            }
        }
    }
    if($fields===array())
    {
        $pks=is_array($table->primaryKey) ? $table->primaryKey : array($table->primaryKey);
        foreach($pks as $pk)
        {
            $fields[]=$table->getColumn($pk)->rawName;
            $placeholders[]=$this->getIntegerPrimaryKeyDefaultValue();
        }
    }
    $sql="INSERT INTO {$table->rawName} (".implode(', ',$fields).') VALUES ('.implode(', ',$placeholders).')';
    $command=$this->_connection->createCommand($sql);

    foreach($values as $name=>$value)
        $command->bindValue($name,$value);

    return $command;
}

另外还有与update、delete等操作对应的方法createUpdateCommand、createDeleteCommand等。

update方法与insert方法的逻辑基本是一致的。

CActiveRecord中所有数据库增、删、改、查操作，在构建出目标sql语句后，都是调用CDbConnection类的方法createCommand来得到一个CDbCommand类的对象，最后调用该对象的execute、query、queryAll等方法来完成查询获取结果。

对于model类实例对象的属性赋值，依赖于CActiveRecord类的方法__set，实现如下：

public function __set($name,$value)
{
    if($this->setAttribute($name,$value)===false)
    {
        if(isset($this->getMetaData()->relations[$name]))
            $this->_related[$name]=$value;
        else
            parent::__set($name,$value);
    }
}

其中调用的setAttribute方法的实现如下：

public function setAttribute($name,$value)
{
    if(property_exists($this,$name))
        $this->$name=$value;
    elseif(isset($this->getMetaData()->columns[$name]))
        $this->_attributes[$name]=$value;
    else
        return false;
    return true;
}

基于CActiveRecord类，如果想进行读取操作，那么子类需要重写model方法。CActiveRecord类的model方法实现如下：

/**
 * Returns the static model of the specified AR class.
 * The model returned is a static instance of the AR class.
 * It is provided for invoking class-level methods (something similar to static class methods.)
 *
 * EVERY derived AR class must override this method as follows,
 * <pre>
 * public static function model($className=__CLASS__)
 * {
 *     return parent::model($className);
 * }
 * </pre>
 *
 * @param string $className active record class name.
 * @return CActiveRecord active record model instance.
 */
public static function model($className=__CLASS__)
{
    if(isset(self::$_models[$className]))
        return self::$_models[$className];
    else
    {
        $model=self::$_models[$className]=new $className(null);
        $model->attachBehaviors($model->behaviors());
        return $model;
    }
}

根据该方法的注释可知道，所有的子类必须如下重写model方法：

public static function model($className = __CLASS__)
{
    return parent::model($className);
}

为什么必须重写model方法呢？因为__CLASS__指的并不是当前对象所属的类，而是方法定义所在的类。

隔壁的哥们告诉我，在 PHP 5.3 之后，如果CActiveRecord的model方法如下实现，就可以不用这样使用需要重写了。

public static function model()
{
    $className = get_called_class();
    if(isset(self::$_models[$className]))
        return self::$_models[$className];
    else
    {
        $model=self::$_models[$className]=new $className(null);
        $model->attachBehaviors($model->behaviors());
        return $model;
    }
}

在得到$model后，就可以调用对象的query、find、findAll、findByPk、findAllByPk、findByAttributes、findAllByAttributes、findBySql、findAllBySql等方法来查询数据。其中find、findAll、findByPk、findAllByPk、findByAttributes、findAllByAttributes最终是通过调用query方法来实现查询的。query方法的第一个参数是一个CDbCriteria类实例对象，这就意味着调用query方法来实现查询的方法需要根据参数实例化一个CDbCriteria类对象。如find方法实现如下：

/**
 * Finds a single active record with the specified condition.
 * @param mixed $condition query condition or criteria.
 * If a string, it is treated as query condition (the WHERE clause);
 * If an array, it is treated as the initial values for constructing a {@link CDbCriteria} object;
 * Otherwise, it should be an instance of {@link CDbCriteria}.
 * @param array $params parameters to be bound to an SQL statement.
 * This is only used when the first parameter is a string (query condition).
 * In other cases, please use {@link CDbCriteria::params} to set parameters.
 * @return CActiveRecord the record found. Null if no record is found.
 */
public function find($condition='',$params=array())
{
    Yii::trace(get_class($this).'.find()','system.db.ar.CActiveRecord');
    // 实例化一个CDbCriteria对象
    $criteria=$this->getCommandBuilder()->createCriteria($condition,$params);
    return $this->query($criteria);
}

而query方法的实现如下所示：

protected function query($criteria,$all=false)
{
    $this->beforeFind();
    $this->applyScopes($criteria);

    if(empty($criteria->with))
    {
        if(!$all)
            $criteria->limit=1;
        // createFindCommand在上面提过
        $command=$this->getCommandBuilder()->createFindCommand($this->getTableSchema(),$criteria,$this->getTableAlias());
        return $all ? $this->populateRecords($command->queryAll(), true, $criteria->index) : $this->populateRecord($command->queryRow());
    }
    else
    {
        $finder=$this->getActiveFinder($criteria->with);
        return $finder->query($criteria,$all);
    }
}

对于查询操作，很多时候需要多表关联查询。那么基于CActiveRecord如何实现多表关联查询（隐式自动地）呢？

CActiveRecord类有个方法relations()：

public function relations()
{
    return array();
}

这个方法的注释非常长，说明如何通过该方法声明当前model对应的数据表有哪些关联数据表，是何种关联关系。继承自CActiveRecord类的model类若想使用隐式的多表关联查询，则需要重写该方法。

举例来说，有数据表UserContacts、Users，UserContacts中有外键字段user_id关联到Users。如果基于CActiveRecord在查询UserContacts记录时，需要便捷地获取关联Users的记录。那么可以在UserContacts数据表对应的model类中，这样重写relations方法：

public function relations()
{
    return array(
            'user' => array(self::BELONGS_TO, 'Users', 'user_id'),
    );
}

那么在得到一条记录对象（$uc）时，通过调用$uc->user，即可得到与该UserContacts记录关联的Users记录。不过这条关联记录的获取可能是在调用$uc->user时才去查询数据库的。

若想提前将关联记录查询出来准备好，则可以再调用find、findAll等查询方法之前先调用with方法，如self::model()->with('user')->find(array('usercontact_id' => 1))，或者这样调用find方法self::model()->find(array('usercontact_id' => 1, 'with' => 'user'))。

那么在调用$uc->user时，如何知道user是一个关联项，而不是一个当前对象的属性？如果当前对象对应的数据表已有一个名为user的字段，是否会屏蔽掉关联项？且看CActiveRecord类的__get方法：

public function __get($name)
{
    // 先查看当前model类对应的数据表是否有名为$name的字段
    if(isset($this->_attributes[$name]))
        return $this->_attributes[$name];
    elseif(isset($this->getMetaData()->columns[$name]))
        return null;
    // 查看是否有名为$name的关联项
    elseif(isset($this->_related[$name]))
        return $this->_related[$name];
    elseif(isset($this->getMetaData()->relations[$name]))
        return $this->getRelated($name);
    else
        return parent::__get($name);
}

注：本文为草稿状态