CActiveRecord

public function __call($name,$parameters)
{
    if(isset($this->getMetaData()->relations[$name]))
    {
        if(empty($parameters))
            return $this->getRelated($name,false);
        else
            return $this->getRelated($name,false,$parameters[0]);
    }

    $scopes=$this->scopes();
    if(isset($scopes[$name]))
    {
        $this->getDbCriteria()->mergeWith($scopes[$name]);
        return $this;
    }

    return parent::__call($name,$parameters);
}

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

public function __get($name)
{
    if(isset($this->_attributes[$name]))
        return $this->_attributes[$name];
    elseif(isset($this->getMetaData()->columns[$name]))
        return null;
    elseif(isset($this->_related[$name]))
        return $this->_related[$name];
    elseif(isset($this->getMetaData()->relations[$name]))
        return $this->getRelated($name);
    else
        return parent::__get($name);
}

public function __isset($name)
{
    if(isset($this->_attributes[$name]))
        return true;
    elseif(isset($this->getMetaData()->columns[$name]))
        return false;
    elseif(isset($this->_related[$name]))
        return true;
    elseif(isset($this->getMetaData()->relations[$name]))
        return $this->getRelated($name)!==null;
    else
        return parent::__isset($name);
}

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

public function __sleep()
{
    return array_keys((array)$this);
}

public function __unset($name)
{
    if(isset($this->getMetaData()->columns[$name]))
        unset($this->_attributes[$name]);
    elseif(isset($this->getMetaData()->relations[$name]))
        unset($this->_related[$name]);
    else
        parent::__unset($name);
}

public function addRelatedRecord($name,$record,$index)
{
    if($index!==false)
    {
        if(!isset($this->_related[$name]))
            $this->_related[$name]=array();
        if($record instanceof CActiveRecord)
        {
            if($index===true)
                $this->_related[$name][]=$record;
            else
                $this->_related[$name][$index]=$record;
        }
    }
    elseif(!isset($this->_related[$name]))
        $this->_related[$name]=$record;
}

protected function afterDelete()
{
    if($this->hasEventHandler('onAfterDelete'))
        $this->onAfterDelete(new CEvent($this));
}

protected function afterFind()
{
    if($this->hasEventHandler('onAfterFind'))
        $this->onAfterFind(new CEvent($this));
}

public function afterFindInternal()
{
    $this->afterFind();
}

protected function afterSave()
{
    if($this->hasEventHandler('onAfterSave'))
        $this->onAfterSave(new CEvent($this));
}

public function applyScopes(&$criteria)
{
    if(!empty($criteria->scopes))
    {
        $scs=$this->scopes();
        $c=$this->getDbCriteria();
        foreach((array)$criteria->scopes as $k=>$v)
        {
            if(is_integer($k))
            {
                if(is_string($v))
                {
                    if(isset($scs[$v]))
                    {
                        $c->mergeWith($scs[$v],true);
                        continue;
                    }
                    $scope=$v;
                    $params=array();
                }
                elseif(is_array($v))
                {
                    $scope=key($v);
                    $params=current($v);
                }
            }
            elseif(is_string($k))
            {
                $scope=$k;
                $params=$v;
            }

            call_user_func_array(array($this,$scope),(array)$params);
        }
    }

    if(isset($c) || ($c=$this->getDbCriteria(false))!==null)
    {
        $c->mergeWith($criteria);
        $criteria=$c;
        $this->resetScope(false);
    }
}

public function attributeNames()
{
    return array_keys($this->getMetaData()->columns);
}

protected function beforeCount()
{
    if($this->hasEventHandler('onBeforeCount'))
        $this->onBeforeCount(new CEvent($this));
}

protected function beforeDelete()
{
    if($this->hasEventHandler('onBeforeDelete'))
    {
        $event=new CModelEvent($this);
        $this->onBeforeDelete($event);
        return $event->isValid;
    }
    else
        return true;
}

protected function beforeFind()
{
    if($this->hasEventHandler('onBeforeFind'))
    {
        $event=new CModelEvent($this);
        $this->onBeforeFind($event);
    }
}

public function beforeFindInternal()
{
    $this->beforeFind();
}

protected function beforeSave()
{
    if($this->hasEventHandler('onBeforeSave'))
    {
        $event=new CModelEvent($this);
        $this->onBeforeSave($event);
        return $event->isValid;
    }
    else
        return true;
}

public function cache($duration, $dependency=null, $queryCount=1)
{
    $this->getDbConnection()->cache($duration, $dependency, $queryCount);
    return $this;
}

public function count($condition='',$params=array())
{
    Yii::trace(get_class($this).'.count()','system.db.ar.CActiveRecord');
    $this->beforeCount();
    $builder=$this->getCommandBuilder();
    $criteria=$builder->createCriteria($condition,$params);
    $this->applyScopes($criteria);

    if(empty($criteria->with))
        return $builder->createCountCommand($this->getTableSchema(),$criteria)->queryScalar();
    else
    {
        $finder=$this->getActiveFinder($criteria->with);
        return $finder->count($criteria);
    }
}

public function countByAttributes($attributes,$condition='',$params=array())
{
    Yii::trace(get_class($this).'.countByAttributes()','system.db.ar.CActiveRecord');
    $prefix=$this->getTableAlias(true).'.';
    $builder=$this->getCommandBuilder();
    $this->beforeCount();
    $criteria=$builder->createColumnCriteria($this->getTableSchema(),$attributes,$condition,$params,$prefix);
    $this->applyScopes($criteria);

    if(empty($criteria->with))
        return $builder->createCountCommand($this->getTableSchema(),$criteria)->queryScalar();
    else
    {
        $finder=$this->getActiveFinder($criteria->with);
        return $finder->count($criteria);
    }
}

public function countBySql($sql,$params=array())
{
    Yii::trace(get_class($this).'.countBySql()','system.db.ar.CActiveRecord');
    $this->beforeCount();
    return $this->getCommandBuilder()->createSqlCommand($sql,$params)->queryScalar();
}

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

public function delete()
{
    if(!$this->getIsNewRecord())
    {
        Yii::trace(get_class($this).'.delete()','system.db.ar.CActiveRecord');
        if($this->beforeDelete())
        {
            $result=$this->deleteByPk($this->getPrimaryKey())>0;
            $this->afterDelete();
            return $result;
        }
        else
            return false;
    }
    else
        throw new CDbException(Yii::t('yii','The active record cannot be deleted because it is new.'));
}

public function deleteAll($condition='',$params=array())
{
    Yii::trace(get_class($this).'.deleteAll()','system.db.ar.CActiveRecord');
    $builder=$this->getCommandBuilder();
    $criteria=$builder->createCriteria($condition,$params);
    $command=$builder->createDeleteCommand($this->getTableSchema(),$criteria);
    return $command->execute();
}

public function deleteAllByAttributes($attributes,$condition='',$params=array())
{
    Yii::trace(get_class($this).'.deleteAllByAttributes()','system.db.ar.CActiveRecord');
    $builder=$this->getCommandBuilder();
    $table=$this->getTableSchema();
    $criteria=$builder->createColumnCriteria($table,$attributes,$condition,$params);
    $command=$builder->createDeleteCommand($table,$criteria);
    return $command->execute();
}

public function deleteByPk($pk,$condition='',$params=array())
{
    Yii::trace(get_class($this).'.deleteByPk()','system.db.ar.CActiveRecord');
    $builder=$this->getCommandBuilder();
    $criteria=$builder->createPkCriteria($this->getTableSchema(),$pk,$condition,$params);
    $command=$builder->createDeleteCommand($this->getTableSchema(),$criteria);
    return $command->execute();
}

public function equals($record)
{
    return $this->tableName()===$record->tableName() && $this->getPrimaryKey()===$record->getPrimaryKey();
}

public function exists($condition='',$params=array())
{
    Yii::trace(get_class($this).'.exists()','system.db.ar.CActiveRecord');
    $builder=$this->getCommandBuilder();
    $criteria=$builder->createCriteria($condition,$params);
    $table=$this->getTableSchema();
    $criteria->select='1';
    $criteria->limit=1;
    $this->applyScopes($criteria);

    if(empty($criteria->with))
        return $builder->createFindCommand($table,$criteria,$this->getTableAlias(false, false))->queryRow()!==false;
    else
    {
        $criteria->select='*';
        $finder=$this->getActiveFinder($criteria->with);
        return $finder->count($criteria)>0;
    }
}

public function find($condition='',$params=array())
{
    Yii::trace(get_class($this).'.find()','system.db.ar.CActiveRecord');
    $criteria=$this->getCommandBuilder()->createCriteria($condition,$params);
    return $this->query($criteria);
}

public function findAll($condition='',$params=array())
{
    Yii::trace(get_class($this).'.findAll()','system.db.ar.CActiveRecord');
    $criteria=$this->getCommandBuilder()->createCriteria($condition,$params);
    return $this->query($criteria,true);
}

public function findAllByAttributes($attributes,$condition='',$params=array())
{
    Yii::trace(get_class($this).'.findAllByAttributes()','system.db.ar.CActiveRecord');
    $prefix=$this->getTableAlias(true).'.';
    $criteria=$this->getCommandBuilder()->createColumnCriteria($this->getTableSchema(),$attributes,$condition,$params,$prefix);
    return $this->query($criteria,true);
}

public function findAllByPk($pk,$condition='',$params=array())
{
    Yii::trace(get_class($this).'.findAllByPk()','system.db.ar.CActiveRecord');
    $prefix=$this->getTableAlias(true).'.';
    $criteria=$this->getCommandBuilder()->createPkCriteria($this->getTableSchema(),$pk,$condition,$params,$prefix);
    return $this->query($criteria,true);
}

public function findAllBySql($sql,$params=array())
{
    Yii::trace(get_class($this).'.findAllBySql()','system.db.ar.CActiveRecord');
    $this->beforeFind();
    if(($criteria=$this->getDbCriteria(false))!==null && !empty($criteria->with))
    {
        $this->resetScope(false);
        $finder=$this->getActiveFinder($criteria->with);
        return $finder->findAllBySql($sql,$params);
    }
    else
    {
        $command=$this->getCommandBuilder()->createSqlCommand($sql,$params);
        return $this->populateRecords($command->queryAll());
    }
}

public function findByAttributes($attributes,$condition='',$params=array())
{
    Yii::trace(get_class($this).'.findByAttributes()','system.db.ar.CActiveRecord');
    $prefix=$this->getTableAlias(true).'.';
    $criteria=$this->getCommandBuilder()->createColumnCriteria($this->getTableSchema(),$attributes,$condition,$params,$prefix);
    return $this->query($criteria);
}

public function findByPk($pk,$condition='',$params=array())
{
    Yii::trace(get_class($this).'.findByPk()','system.db.ar.CActiveRecord');
    $prefix=$this->getTableAlias(true).'.';
    $criteria=$this->getCommandBuilder()->createPkCriteria($this->getTableSchema(),$pk,$condition,$params,$prefix);
    return $this->query($criteria);
}

public function findBySql($sql,$params=array())
{
    Yii::trace(get_class($this).'.findBySql()','system.db.ar.CActiveRecord');
    $this->beforeFind();
    if(($criteria=$this->getDbCriteria(false))!==null && !empty($criteria->with))
    {
        $this->resetScope(false);
        $finder=$this->getActiveFinder($criteria->with);
        return $finder->findBySql($sql,$params);
    }
    else
    {
        $command=$this->getCommandBuilder()->createSqlCommand($sql,$params);
        return $this->populateRecord($command->queryRow());
    }
}

public function getActiveFinder($with)
{
    return new CActiveFinder($this,$with);
}

public function getActiveRelation($name)
{
    return isset($this->getMetaData()->relations[$name]) ? $this->getMetaData()->relations[$name] : null;
}

public function getAttribute($name)
{
    if(property_exists($this,$name))
        return $this->$name;
    elseif(isset($this->_attributes[$name]))
        return $this->_attributes[$name];
}

public function getAttributeLabel($attribute)
{
    $labels=$this->attributeLabels();
    if(isset($labels[$attribute]))
        return $labels[$attribute];
    elseif(strpos($attribute,'.')!==false)
    {
        $segs=explode('.',$attribute);
        $name=array_pop($segs);
        $model=$this;
        foreach($segs as $seg)
        {
            $relations=$model->getMetaData()->relations;
            if(isset($relations[$seg]))
                $model=CActiveRecord::model($relations[$seg]->className);
            else
                break;
        }
        return $model->getAttributeLabel($name);
    }
    else
        return $this->generateAttributeLabel($attribute);
}

public function getAttributes($names=true)
{
    $attributes=$this->_attributes;
    foreach($this->getMetaData()->columns as $name=>$column)
    {
        if(property_exists($this,$name))
            $attributes[$name]=$this->$name;
        elseif($names===true && !isset($attributes[$name]))
            $attributes[$name]=null;
    }
    if(is_array($names))
    {
        $attrs=array();
        foreach($names as $name)
        {
            if(property_exists($this,$name))
                $attrs[$name]=$this->$name;
            else
                $attrs[$name]=isset($attributes[$name])?$attributes[$name]:null;
        }
        return $attrs;
    }
    else
        return $attributes;
}

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

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

public function getDbCriteria($createIfNull=true)
{
    if($this->_c===null)
    {
        if(($c=$this->defaultScope())!==array() || $createIfNull)
            $this->_c=new CDbCriteria($c);
    }
    return $this->_c;
}

public function getIsNewRecord()
{
    return $this->_new;
}

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

public function getOldPrimaryKey()
{
    return $this->_pk;
}

public function getPrimaryKey()
{
    $table=$this->getTableSchema();
    if(is_string($table->primaryKey))
        return $this->{$table->primaryKey};
    elseif(is_array($table->primaryKey))
    {
        $values=array();
        foreach($table->primaryKey as $name)
            $values[$name]=$this->$name;
        return $values;
    }
    else
        return null;
}

public function getRelated($name,$refresh=false,$params=array())
{
    if(!$refresh && $params===array() && (isset($this->_related[$name]) || array_key_exists($name,$this->_related)))
        return $this->_related[$name];

    $md=$this->getMetaData();
    if(!isset($md->relations[$name]))
        throw new CDbException(Yii::t('yii','{class} does not have relation "{name}".',
            array('{class}'=>get_class($this), '{name}'=>$name)));

    Yii::trace('lazy loading '.get_class($this).'.'.$name,'system.db.ar.CActiveRecord');
    $relation=$md->relations[$name];
    if($this->getIsNewRecord() && !$refresh && ($relation instanceof CHasOneRelation || $relation instanceof CHasManyRelation))
        return $relation instanceof CHasOneRelation ? null : array();

    if($params!==array()) // dynamic query
    {
        $exists=isset($this->_related[$name]) || array_key_exists($name,$this->_related);
        if($exists)
            $save=$this->_related[$name];

        if($params instanceof CDbCriteria)
            $params = $params->toArray();

        $r=array($name=>$params);
    }
    else
        $r=$name;
    unset($this->_related[$name]);

    $finder=$this->getActiveFinder($r);
    $finder->lazyFind($this);

    if(!isset($this->_related[$name]))
    {
        if($relation instanceof CHasManyRelation)
            $this->_related[$name]=array();
        elseif($relation instanceof CStatRelation)
            $this->_related[$name]=$relation->defaultValue;
        else
            $this->_related[$name]=null;
    }

    if($params!==array())
    {
        $results=$this->_related[$name];
        if($exists)
            $this->_related[$name]=$save;
        else
            unset($this->_related[$name]);
        return $results;
    }
    else
        return $this->_related[$name];
}

public function getTableAlias($quote=false, $checkScopes=true)
{
    if($checkScopes && ($criteria=$this->getDbCriteria(false))!==null && $criteria->alias!='')
        $alias=$criteria->alias;
    else
        $alias=$this->_alias;
    return $quote ? $this->getDbConnection()->getSchema()->quoteTableName($alias) : $alias;
}

public function getTableSchema()
{
    return $this->getMetaData()->tableSchema;
}

public function hasAttribute($name)
{
    return isset($this->getMetaData()->columns[$name]);
}

public function hasRelated($name)
{
    return isset($this->_related[$name]) || array_key_exists($name,$this->_related);
}

public function init()
{
}

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->getTableSchema();
        $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;
}

protected function instantiate($attributes)
{
    $class=get_class($this);
    $model=new $class(null);
    return $model;
}

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

public function offsetExists($offset)
{
    return $this->__isset($offset);
}

public function onAfterDelete($event)
{
    $this->raiseEvent('onAfterDelete',$event);
}

public function onAfterFind($event)
{
    $this->raiseEvent('onAfterFind',$event);
}

public function onAfterSave($event)
{
    $this->raiseEvent('onAfterSave',$event);
}

public function onBeforeCount($event)
{
    $this->raiseEvent('onBeforeCount',$event);
}

public function onBeforeDelete($event)
{
    $this->raiseEvent('onBeforeDelete',$event);
}

public function onBeforeFind($event)
{
    $this->raiseEvent('onBeforeFind',$event);
}

public function onBeforeSave($event)
{
    $this->raiseEvent('onBeforeSave',$event);
}

public function populateRecord($attributes,$callAfterFind=true)
{
    if($attributes!==false)
    {
        $record=$this->instantiate($attributes);
        $record->setScenario('update');
        $record->init();
        $md=$record->getMetaData();
        foreach($attributes as $name=>$value)
        {
            if(property_exists($record,$name))
                $record->$name=$value;
            elseif(isset($md->columns[$name]))
                $record->_attributes[$name]=$value;
        }
        $record->_pk=$record->getPrimaryKey();
        $record->attachBehaviors($record->behaviors());
        if($callAfterFind)
            $record->afterFind();
        return $record;
    }
    else
        return null;
}

public function populateRecords($data,$callAfterFind=true,$index=null)
{
    $records=array();
    foreach($data as $attributes)
    {
        if(($record=$this->populateRecord($attributes,$callAfterFind))!==null)
        {
            if($index===null)
                $records[]=$record;
            else
                $records[$record->$index]=$record;
        }
    }
    return $records;
}

public function primaryKey()
{
}

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

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

public function refresh()
{
    Yii::trace(get_class($this).'.refresh()','system.db.ar.CActiveRecord');
    if(($record=$this->findByPk($this->getPrimaryKey()))!==null)
    {
        $this->_attributes=array();
        $this->_related=array();
        foreach($this->getMetaData()->columns as $name=>$column)
        {
            if(property_exists($this,$name))
                $this->$name=$record->$name;
            else
                $this->_attributes[$name]=$record->$name;
        }
        return true;
    }
    else
        return false;
}

public function refreshMetaData()
{
    $className=get_class($this);
    if(array_key_exists($className,self::$_md))
        unset(self::$_md[$className]);
}

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

public function resetScope($resetDefault=true)
{
    if($resetDefault)
        $this->_c=new CDbCriteria();
    else
        $this->_c=null;

    return $this;
}

public function save($runValidation=true,$attributes=null)
{
    if(!$runValidation || $this->validate($attributes))
        return $this->getIsNewRecord() ? $this->insert($attributes) : $this->update($attributes);
    else
        return false;
}

public function saveAttributes($attributes)
{
    if(!$this->getIsNewRecord())
    {
        Yii::trace(get_class($this).'.saveAttributes()','system.db.ar.CActiveRecord');
        $values=array();
        foreach($attributes as $name=>$value)
        {
            if(is_integer($name))
                $values[$value]=$this->$value;
            else
                $values[$name]=$this->$name=$value;
        }
        if($this->_pk===null)
            $this->_pk=$this->getPrimaryKey();
        if($this->updateByPk($this->getOldPrimaryKey(),$values)>0)
        {
            $this->_pk=$this->getPrimaryKey();
            return true;
        }
        else
            return false;
    }
    else
        throw new CDbException(Yii::t('yii','The active record cannot be updated because it is new.'));
}

public function saveCounters($counters)
{
    Yii::trace(get_class($this).'.saveCounters()','system.db.ar.CActiveRecord');
    $builder=$this->getCommandBuilder();
    $table=$this->getTableSchema();
    $criteria=$builder->createPkCriteria($table,$this->getOldPrimaryKey());
    $command=$builder->createUpdateCounterCommand($this->getTableSchema(),$counters,$criteria);
    if($command->execute())
    {
        foreach($counters as $name=>$value)
            $this->$name=$this->$name+$value;
        return true;
    }
    else
        return false;
}

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

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

public function setDbCriteria($criteria)
{
    $this->_c=$criteria;
}

public function setIsNewRecord($value)
{
    $this->_new=$value;
}

public function setOldPrimaryKey($value)
{
    $this->_pk=$value;
}

public function setPrimaryKey($value)
{
    $this->_pk=$this->getPrimaryKey();
    $table=$this->getTableSchema();
    if(is_string($table->primaryKey))
        $this->{$table->primaryKey}=$value;
    elseif(is_array($table->primaryKey))
    {
        foreach($table->primaryKey as $name)
            $this->$name=$value[$name];
    }
}

public function setTableAlias($alias)
{
    $this->_alias=$alias;
}

public function tableName()
{
    $tableName = get_class($this);
    if(($pos=strrpos($tableName,'\\')) !== false)
        return substr($tableName,$pos+1);
    return $tableName;
}

public function together()
{
    $this->getDbCriteria()->together=true;
    return $this;
}

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();
        $this->updateByPk($this->getOldPrimaryKey(),$this->getAttributes($attributes));
        $this->_pk=$this->getPrimaryKey();
        $this->afterSave();
        return true;
    }
    else
        return false;
}

public function updateAll($attributes,$condition='',$params=array())
{
    Yii::trace(get_class($this).'.updateAll()','system.db.ar.CActiveRecord');
    $builder=$this->getCommandBuilder();
    $criteria=$builder->createCriteria($condition,$params);
    $command=$builder->createUpdateCommand($this->getTableSchema(),$attributes,$criteria);
    return $command->execute();
}

public function updateByPk($pk,$attributes,$condition='',$params=array())
{
    Yii::trace(get_class($this).'.updateByPk()','system.db.ar.CActiveRecord');
    $builder=$this->getCommandBuilder();
    $table=$this->getTableSchema();
    $criteria=$builder->createPkCriteria($table,$pk,$condition,$params);
    $command=$builder->createUpdateCommand($table,$attributes,$criteria);
    return $command->execute();
}