https://www.jmqz1000.com

[李景山php]thinkphp核心源码注释-Model.class.php

  • <?php
    // +----------------------------------------------------------------------
    // | ThinkPHP [ WE CAN DO IT JUST THINK IT ]
    // +----------------------------------------------------------------------
    // | Copyright (c) 2006-2014 http://thinkphp.cn All rights reserved.
    // +----------------------------------------------------------------------
    // | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
    // +----------------------------------------------------------------------
    // | Author: liu21st <liu21st@gmail.com>
    // +----------------------------------------------------------------------
    namespace Think;
    /**
     * ThinkPHP Model模型类
     * 实现了ORM和ActiveRecords模式
     */
    html' target='_blank'>class Model {
        // 操作状态
        const MODEL_INSERT          =   1;      //  插入模型数据
        const MODEL_UPDATE          =   2;      //  更新模型数据
        const MODEL_BOTH            =   3;      //  包含上面两种方式
        const MUST_VALIDATE         =   1;      // 必须验证
        const EXISTS_VALIDATE       =   0;      // 表单存在字段则验证
        const VALUE_VALIDATE        =   2;      // 表单值不为空则验证
        // 开始的 变量 定义
        // 据说 const 比 那里的 define 里面 效果要好一些, 貌似在 class里面只能用 const 定义的。
    
        // 当前数据库操作对象
        protected $db               =   null; // 这里要 获取 数据库操作对象
        // 数据库对象池
        private   $_db             =   array(); // 操作对象池  估计是给到分布式 连接使用的
        // 主键名称
        protected $pk               =   'id'; // 就是这里,给定了默认的 那个。
        // 主键是否自动增长
        protected $autoinc          =   false;    // 默认 是否 会自动 增长
        // 数据表前缀
        protected $tablePrefix      =   null;// 数据库表前缀,然而这个基本上都被自己重新定义了
        // 模型名称
        protected $name             =   ''; // 模型的开始
        // 数据库名称
        protected $dbName           =   '';// 数据库 名称了
        //数据库配置
        protected $connection       =   '';// 数据库 配置
        // 数据表名(不包含表前缀)
        protected $tableName        =   ''; // 数据表
        // 实际数据表名(包含表前缀)
        protected $trueTableName    =   '';// 组合后表名
        // 最近错误信息
        protected $error            =   '';// 错误信息
        // 字段信息
        protected $fields           =   array();// 可以获取到字段信息
        // 数据信息
        protected $data             =   array(); // 产生出来的 数据
        // 查询表达式参数
        protected $options          =   array();// 参数 开始
        protected $_validate        =   array();  // 自动验证定义
        protected $_auto            =   array();  // 自动完成定义
        protected $_map             =   array();  // 字段映射定义  用到的不多
        protected $_scope           =   array();  // 命名范围定义  这里没怎么用到
        // 是否自动检测数据表字段信息
        protected $autoCheckFields  =   true; // 是否开启自己的自动检测
        // 是否批处理验证
        protected $patchValidate    =   false;// 是否处理验证
        // 链操作方法列表
        protected $methods          =   array('strict','order','alias','having','group','lock','distinct','auto','filter','validate','result','token','index','force');
        // 链式操作的 白名单
        // 第一阶段: 代码 变量 常量 定义
        // 总结:到了最后的这个,发现了 其实在类里面,也是先准备一个 各种数据的,开始。
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
        /**
         * 得到当前的数据对象名称
         * @access public
         * @return string
         */
        public function getModelName() {
            if(empty($this->name)){
                // 继承 自己的 get_class($this)
                $name = substr(get_class($this),0,-strlen(C('DEFAULT_M_LAYER'))); //    'DEFAULT_M_LAYER'       =>  'Model', // 默认的模型层名称
                if ( $pos = strrpos($name,'\\') ) {//有命名空间
                    $this->name = substr($name,$pos+1);// 获取其 对象
                }else{
                    $this->name = $name;
                }
            }
            return $this->name;
        }
        // 回调方法 初始化模型
        protected function _initialize() {}
        /**
         * 切换当前的数据库连接
         * @access public
         * @param integer $linkNum  连接序号
         * @param mixed $config  数据库连接信息
         * @param boolean $force 强制重新连接
         * @return Model
         * $this->db(0,empty($this->connection)?$connection:$this->connection,true);
         */
        public function db($linkNum='',$config='',$force=false) {
            if('' === $linkNum && $this->db) {
                return $this->db;
            }// 这种就是返回 当前的 数据库了,普通的调用是没有的
    
            if(!isset($this->_db[$linkNum]) || $force ) { // 如果没有当前序号的连接, 或者可以强制 重启连接
                // 创建一个新的实例
                if(!empty($config) && is_string($config) && false === strpos($config,'/')) { // 支持读取配置参数
                    $config  =  C($config);
                }// 重新 配置 $config
                $this->_db[$linkNum]            =    Db::getInstance($config); // 返回数据库 的连接
                // 获取个 数据库的 实例化
            }elseif(NULL === $config){ // 如果配置为空的
                $this->_db[$linkNum]->close(); // 关闭数据库连接
                unset($this->_db[$linkNum]);
                return ;
            }
            // 进行数据库连接 的实例化
    
            // 切换数据库连接
            $this->db   =    $this->_db[$linkNum];
            $this->_after_db(); // 钩子函数
            // 字段检测
            if(!empty($this->name) && $this->autoCheckFields)    $this->_checkTableInfo();
            // 开始了 那里的 检测表
            return $this;
        }
        // 数据库切换后回调方法
        protected function _after_db() {}
        /**
         * 自动检测数据表信息
         * @access protected
         * @return void
         */
        protected function _checkTableInfo() {
            // 如果不是Model类 自动记录数据表信息
            // 只在第一次执行记录
            if(empty($this->fields)) { // 没有记录开始
                // 如果数据表字段没有定义则自动获取
                if(C('DB_FIELDS_CACHE')) { // 'DB_FIELDS_CACHE'       =>  true,        // 启用字段缓存
                    $db   =  $this->dbName?:C('DB_NAME'); // 'DB_NAME'               =>  '',          // 数据库名
                    $fields = F('_fields/'.strtolower($db.'.'.$this->tablePrefix.$this->name));// 读取其缓存 数值
                    // 快速文件数据读取和保存 针对简单类型数据 字符串、数组
                    if($fields) {
                        $this->fields   =   $fields;
                        if(!empty($fields['_pk'])){
                            $this->pk       =   $fields['_pk'];
                        }
                        return ;
                    }// 更新 当前的 存储
                }
                // 每次都会读取数据表信息
                $this->flush(); // 刷新一下 缓存
            }
        }
        /**
         * 获取字段信息并缓存
         * @access public
         * @return void
         */
        public function flush() {
            // 缓存不存在则查询数据表信息
            $this->db->setModel($this->name);
            $fields =   $this->db->getFields($this->getTableName());
            if(!$fields) { // 无法获取字段信息
                return false;
            }
            $this->fields   =   array_keys($fields);
            unset($this->fields['_pk']);
            foreach ($fields as $key=>$val){
                // 记录字段类型
                $type[$key]     =   $val['type'];
                if($val['primary']) {
                    // 增加复合主键支持
                    if (isset($this->fields['_pk']) && $this->fields['_pk'] != null) {
                        if (is_string($this->fields['_pk'])) {
                            $this->pk   =   array($this->fields['_pk']);
                            $this->fields['_pk']   =   $this->pk;
                        }
                        $this->pk[]   =   $key;
                        $this->fields['_pk'][]   =   $key;
                    } else {
                        $this->pk   =   $key;
                        $this->fields['_pk']   =   $key;
                    }
                    if($val['autoinc']) $this->autoinc   =   true;
                }
            }
            // 记录字段类型信息
            $this->fields['_type'] =  $type;
    
            // 2008-3-7 增加缓存开关控制
            if(C('DB_FIELDS_CACHE')){
                // 永久缓存数据表信息
                $db   =  $this->dbName?:C('DB_NAME');
                F('_fields/'.strtolower($db.'.'.$this->tablePrefix.$this->name),$this->fields);
            }
        }// 就是 刷新个字段呗。
        /**
         * 架构函数
         * 取得DB类的实例对象 字段检查
         * @access public
         * @param string $name 模型名称
         * @param string $tablePrefix 表前缀
         * @param mixed $connection 数据库连接信息
         */
        public function __construct($name='',$tablePrefix='',$connection='') {
            // 其实 我们经常使用的 M();这里的 应该就是实例化这里的
            // 模型初始化
            $this->_initialize(); // 是空的。 此处没有任何代码,留出了很多代码接口,
            // 获取模型名称 M()
            if(!empty($name)) {
                if(strpos($name,'.')) { // 支持 数据库名.模型名的 定义
                    list($this->dbName,$this->name) = explode('.',$name); // 应该是 数据库名   数据表名
                }else{
                    $this->name   =  $name;
                }
            }elseif(empty($this->name)){
                $this->name =   $this->getModelName();
            }
            // 产生 两个
            // $this->name  这个其实是数据表 名字
            // $this->dbName  数据库名称
    
            // 设置表前缀
            if(is_null($tablePrefix)) {// 前缀为Null表示没有前缀
                $this->tablePrefix = '';
            }elseif('' != $tablePrefix) {
                $this->tablePrefix = $tablePrefix;
            }elseif(!isset($this->tablePrefix)){ // 实际中,会执行这个
                $this->tablePrefix = C('DB_PREFIX');// 这个才是
            }
            // 这里的代码执行了
            // 数据库初始化操作
            // 获取数据库操作对象
            // 当前模型有独立的数据库连接信息
            $this->db(0,empty($this->connection)?$connection:$this->connection,true); // 进行连接 操作。
            //切换当前的数据库连接
        }
        // 总结:你一个函数 折腾出这么多事情来,呵呵
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
        /**
         * 设置数据对象的值
         * @access public
         * @param string $name 名称
         * @param mixed $value 值
         * @return void
         */
        public function __set($name,$value) {
            // 设置数据对象属性
            $this->data[$name]  =   $value;
        }// 普通 默认设置
    
        /**
         * 获取数据对象的值
         * @access public
         * @param string $name 名称
         * @return mixed
         */
        public function __get($name) {
            return isset($this->data[$name])?$this->data[$name]:null;
        }// 普通 默认设置
    
        /**
         * 检测数据对象的值
         * @access public
         * @param string $name 名称
         * @return boolean
         */
        public function __isset($name) {
            return isset($this->data[$name]);
        }// 普通 默认设置
    
        /**
         * 销毁数据对象的值
         * @access public
         * @param string $name 名称
         * @return void
         */
        public function __unset($name) {
            unset($this->data[$name]);
        }// 普通 默认设置
    
        /**
         * 利用__call方法实现一些特殊的Model方法
         * @access public
         * @param string $method 方法名称
         * @param array $args 调用参数
         * @return mixed
         */
        public function __call($method,$args) {
            if(in_array(strtolower($method),$this->methods,true)) { // 链式 操作里面的代码
                // 连贯操作的实现
                $this->options[strtolower($method)] =   $args[0];
                return $this;
            }elseif(in_array(strtolower($method),array('count','sum','min','max','avg'),true)){ // 统计代码
                // 统计查询的实现
                $field =  isset($args[0])?$args[0]:'*';
                return $this->getField(strtoupper($method).'('.$field.') AS tp_'.$method);
            }elseif(strtolower(substr($method,0,5))=='getby') { // 特殊的一个调用
                // 根据某个字段获取记录
                $field   =   parse_name(substr($method,5));
                $where[$field] =  $args[0];
                return $this->where($where)->find();
            }elseif(strtolower(substr($method,0,10))=='getfieldby')  {// 这个可以
                // 根据某个字段获取记录的某个值
                $name   =   parse_name(substr($method,10));
                $where[$name] =$args[0];
                return $this->where($where)->getField($args[1]);
            }elseif(isset($this->_scope[$method])){// 命名范围的单独调用支持
                return $this->scope($method,$args[0]);
            }else{
                E(__CLASS__.':'.$method.L('_METHOD_NOT_EXIST_'));
                return;
            }
        }// 普通 默认设置
        // 符合标准 就执行
    
        /**
         * 数据类型检测
         * @access protected
         * @param mixed $data 数据
         * @param string $key 字段名
         * @return void
         */
        protected function _parseType(&$data,$key) {
            if(!isset($this->options['bind'][':'.$key]) && isset($this->fields['_type'][$key])){
                $fieldType = strtolower($this->fields['_type'][$key]);
                if(false !== strpos($fieldType,'enum')){
                    // 支持ENUM类型优先检测
                }elseif(false === strpos($fieldType,'bigint') && false !== strpos($fieldType,'int')) {
                    $data[$key]   =  intval($data[$key]);
                }elseif(false !== strpos($fieldType,'float') || false !== strpos($fieldType,'double')){
                    $data[$key]   =  floatval($data[$key]);
                }elseif(false !== strpos($fieldType,'bool')){
                    $data[$key]   =  (bool)$data[$key];
                }
            }
        }// 数据类型的 数据转换
        /**
         * 对保存到数据库的数据进行处理
         * @access protected
         * @param mixed $data 要操作的数据
         * @return boolean
         */
         protected function _facade($data) {
    
            // 检查数据字段合法性
            if(!empty($this->fields)) {
                if(!empty($this->options['field'])) {
                    $fields =   $this->options['field'];
                    unset($this->options['field']);
                    if(is_string($fields)) {
                        $fields =   explode(',',$fields);
                    }    
                }else{
                    $fields =   $this->fields;
                }        
                foreach ($data as $key=>$val){
                    if(!in_array($key,$fields,true)){
                        if(!empty($this->options['strict'])){
                            E(L('_DATA_TYPE_INVALID_').':['.$key.'=>'.$val.']');
                        }
                        unset($data[$key]);
                    }elseif(is_scalar($val)) {
                        // 字段类型检查 和 强制转换
                        $this->_parseType($data,$key); // 是转换数据类型
                    }
                }
            }
    
            // 安全过滤
            if(!empty($this->options['filter'])) {
                $data = array_map($this->options['filter'],$data); // 数据跑起来了
                unset($this->options['filter']);
            }
            $this->_before_write($data);
            return $data;
         }//总结,就是对数据的 处理
        // 各种数据 处理
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
        // 写入数据前的回调方法 包括新增和更新
        protected function _before_write(&$data) {}
        // 插入数据前的回调方法
        protected function _before_insert(&$data,$options) {}
        // 插入成功后的回调方法
        protected function _after_insert($data,$options) {}
        /**
         * 分析表达式
         * @access protected
         * @param array $options 表达式参数
         * @return array
         */
        protected function _parseOptions($options=array()) {
            if(is_array($options))
                $options =  array_merge($this->options,$options); // 先合并选项
    
            if(!isset($options['table'])){ // 这里的 获取数据表
                // 自动获取表名
                $options['table']   =   $this->getTableName(); // 获取表名
                $fields             =   $this->fields;// 字段 开始
            }else{
                // 指定数据表 则重新获取字段列表 但不支持类型检测
                $fields             =   $this->getDbFields(); // 字段
            }
    
            // 数据表别名
            if(!empty($options['alias'])) {
                $options['table']  .=   ' '.$options['alias'];
            }
            // 记录操作的模型名称
            $options['model']       =   $this->name; // 操作 模型名
    
            // 字段类型验证
            if(isset($options['where']) && is_array($options['where']) && !empty($fields) && !isset($options['join'])) {
                // 对数组查询条件进行字段类型检查
                foreach ($options['where'] as $key=>$val){
                    $key            =   trim($key);
                    if(in_array($key,$fields,true)){ // 如果 是 什么呢
                        if(is_scalar($val)) {
                            $this->_parseType($options['where'],$key);
                        }
                    }elseif(!is_numeric($key) && '_' != substr($key,0,1) && false === strpos($key,'.') && false === strpos($key,'(') && false === strpos($key,'|') && false === strpos($key,'&')){
                        if(!empty($this->options['strict'])){
                            E(L('_ERROR_QUERY_EXPRESS_').':['.$key.'=>'.$val.']');
                        }
                        unset($options['where'][$key]);
                    }
                }
            }
            // 查询过后清空sql表达式组装 避免影响下次查询
            $this->options  =   array();// 选项处理完成了
            // 表达式过滤
            $this->_options_filter($options);
            return $options;
        }
        // 表达式过滤回调方法
        protected function _options_filter(&$options) {}
        /**
         * 得到完整的数据表名
         * @access public
         * @return string
         */
        public function getTableName() {
            if(empty($this->trueTableName)) {
                $tableName  = !empty($this->tablePrefix) ? $this->tablePrefix : '';
                if(!empty($this->tableName)) {
                    $tableName .= $this->tableName;
                }else{
                    $tableName .= parse_name($this->name); // 大小写字母 转换了
                }
                $this->trueTableName    =   strtolower($tableName);
            }
            return (!empty($this->dbName)?$this->dbName.'.':'').$this->trueTableName;
        }
        /**
         * 新增数据
         * @access public
         * @param mixed $data 数据
         * @param array $options 表达式
         * @param boolean $replace 是否replace
         * @return mixed
         */
        public function add($data='',$options=array(),$replace=false) {
            if(empty($data)) {
                // 没有传递数据,获取当前数据对象的值
                if(!empty($this->data)) {
                    $data           =   $this->data;
                    // 重置数据
                    $this->data     = array();
                }else{
                    $this->error    = L('_DATA_TYPE_INVALID_');
                    return false;
                }
            }
            // 整理 数据,数据整理合格
    
    
            // 数据处理
            $data       =   $this->_facade($data);
            // 分析表达式
            $options    =   $this->_parseOptions($options); // 解析 选项
            if(false === $this->_before_insert($data,$options)) { // 没什么了
                return false;
            }
            // 写入数据到数据库
            $result = $this->db->insert($data,$options,$replace); // 执行数据库的 插入操作  替换而已
            if(false !== $result && is_numeric($result)) {
                $pk     =   $this->getPk(); // 主键
                  // 增加复合主键支持
                if (is_array($pk)) return $result;
                $insertId   =   $this->getLastInsID(); // 获取最后的ID
                if($insertId) {
                    // 自增主键返回插入ID
                    $data[$pk]  = $insertId;
                    if(false === $this->_after_insert($data,$options)) {
                        return false;
                    }
                    return $insertId;
                }
                if(false === $this->_after_insert($data,$options)) {
                    return false;
                }
            }
            return $result;
        }// 单条 切换
    
    
        public function addAll($dataList,$options=array(),$replace=false){
            if(empty($dataList)) { // 如果为空
                $this->error = L('_DATA_TYPE_INVALID_');
                return false;
            }
            // 数据处理
            foreach ($dataList as $key=>$data){
                $dataList[$key] = $this->_facade($data);
            }
            // 分析表达式
            $options =  $this->_parseOptions($options);
            // 写入数据到数据库
            $result = $this->db->insertAll($dataList,$options,$replace);
            if(false !== $result ) {
                $insertId   =   $this->getLastInsID();
                if($insertId) {
                    return $insertId;
                }
            }
            return $result;
        }
        // 这个 外包 为 100分,哈哈
    
        /**
         * 通过Select方式添加记录
         * @access public
         * @param string $fields 要插入的数据表字段名
         * @param string $table 要插入的数据表名
         * @param array $options 表达式
         * @return boolean
         */
        public function selectAdd($fields='',$table='',$options=array()) {
            // 分析表达式
            $options =  $this->_parseOptions($options);
            // 写入数据到数据库
            if(false === $result = $this->db->selectInsert($fields?:$options['field'],$table?:$this->getTableName(),$options)){
                // 数据库插入操作失败
                $this->error = L('_OPERATION_WRONG_');
                return false;
            }else {
                // 插入成功
                return $result;
            }
        }
        // 居然还有这个,很少用啊,不过应该很实用的
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
        /**
         * 保存数据
         * @access public
         * @param mixed $data 数据
         * @param array $options 表达式
         * @return boolean
         */
        public function save($data='',$options=array()) {
            if(empty($data)) {
                // 没有传递数据,获取当前数据对象的值
                if(!empty($this->data)) {
                    $data           =   $this->data;
                    // 重置数据
                    $this->data     =   array();
                }else{
                    $this->error    =   L('_DATA_TYPE_INVALID_');
                    return false;
                }
            }// 这里 第一步 数据处理
            // 数据处理
            $data       =   $this->_facade($data);
            if(empty($data)){
                // 没有数据则不执行
                $this->error    =   L('_DATA_TYPE_INVALID_');
                return false;
            }// 都处理完成了, 没有,就报错呗
            // 分析表达式
            $options    =   $this->_parseOptions($options);// 处理 选项
            $pk         =   $this->getPk();// 处理 主键
            if(!isset($options['where']) ) { // 如果没有设置 where
                // 如果存在主键数据 则自动作为更新条件
                if (is_string($pk) && isset($data[$pk])) {
                    $where[$pk]     =   $data[$pk];
                    unset($data[$pk]);
                } elseif (is_array($pk)) {
                    // 增加复合主键支持
                    foreach ($pk as $field) {
                        if(isset($data[$field])) {
                            $where[$field]      =   $data[$field];
                        } else {
                               // 如果缺少复合主键数据则不执行
                            $this->error        =   L('_OPERATION_WRONG_');
                            return false;
                        }
                        unset($data[$field]);
                    }
                }
                if(!isset($where)){
                    // 如果没有任何更新条件则不执行
                    $this->error        =   L('_OPERATION_WRONG_');
                    return false;
                }else{
                    $options['where']   =   $where;
                }
            }
    
            // 如果就是 已经有了 条件
            if(is_array($options['where']) && isset($options['where'][$pk])){
                $pkValue    =   $options['where'][$pk];
            }
            // 开始
            if(false === $this->_before_update($data,$options)) {
                return false;
            }
            $result     =   $this->db->update($data,$options); //
            if(false !== $result && is_numeric($result)) {
                if(isset($pkValue)) $data[$pk]   =  $pkValue;
                $this->_after_update($data,$options);
            }
            return $result;
        }
        // 外包处理 之前  弄了各种各样的 封包
        // 更新数据前的回调方法
        protected function _before_update(&$data,$options) {}
        // 更新成功后的回调方法
        protected function _after_update($data,$options) {}
        // 处理数据,选项条件,处理好的,发送给对应的 执行这个函数。
        // 这个就是相当于 自己给自己挖了很大的坑,嘿嘿
    
    
        /**
         * 删除数据
         * @access public
         * @param mixed $options 表达式
         * @return mixed
         */
        public function delete($options=array()) {
            $pk   =  $this->getPk(); // 主键
            if(empty($options) && empty($this->options['where'])) {
                // 如果删除条件为空 则删除当前数据对象所对应的记录
                if(!empty($this->data) && isset($this->data[$pk]))
                    return $this->delete($this->data[$pk]);
                else
                    return false;
            }
            if(is_numeric($options)  || is_string($options)) {
                // 根据主键删除记录
                if(strpos($options,',')) {
                    $where[$pk]     =  array('IN', $options);
                }else{
                    $where[$pk]     =  $options;
                }
                $options            =  array();
                $options['where']   =  $where;
            }
            // 根据复合主键删除记录
            if (is_array($options) && (count($options) > 0) && is_array($pk)) {
                $count = 0;
                foreach (array_keys($options) as $key) {
                    if (is_int($key)) $count++; 
                } 
                if ($count == count($pk)) {
                    $i = 0;
                    foreach ($pk as $field) {
                        $where[$field] = $options[$i];
                        unset($options[$i++]);
                    }
                    $options['where']  =  $where;
                } else {
                    return false;
                }
            }
            // 处理了 里面的 东西
            // 分析表达式
            $options =  $this->_parseOptions($options); //
            if(empty($options['where'])){
                // 如果条件为空 不进行删除操作 除非设置 1=1
                return false;
            }        
            if(is_array($options['where']) && isset($options['where'][$pk])){
                $pkValue            =  $options['where'][$pk];
            }
    
            if(false === $this->_before_delete($options)) {
                return false;
            }        
            $result  =    $this->db->delete($options);
            if(false !== $result && is_numeric($result)) {
                $data = array();
                if(isset($pkValue)) $data[$pk]   =  $pkValue;
                $this->_after_delete($data,$options);
            }
            // 返回删除记录个数
            return $result;
        }
        // 删除数据前的回调方法
        protected function _before_delete($options) {}    
        // 删除成功后的回调方法
        protected function _after_delete($data,$options) {}
        // 删除 同上
    
    
    
        /**
         * 查询数据集
         * @access public
         * @param array $options 表达式参数
         * @return mixed
         */
        public function select($options=array()) {
            // option 处理
            $pk   =  $this->getPk();
            if(is_string($options) || is_numeric($options)) {
                // 根据主键查询
                if(strpos($options,',')) {
                    $where[$pk]     =  array('IN',$options);
                }else{
                    $where[$pk]     =  $options;
                }
                $options            =  array();
                $options['where']   =  $where;
            }elseif (is_array($options) && (count($options) > 0) && is_array($pk)) {
                // 根据复合主键查询
                $count = 0;
                foreach (array_keys($options) as $key) {
                    if (is_int($key)) $count++; 
                } 
                if ($count == count($pk)) {
                    $i = 0;
                    foreach ($pk as $field) {
                        $where[$field] = $options[$i];
                        unset($options[$i++]);
                    }
                    $options['where']  =  $where;
                } else {
                    return false;
                }
            } elseif(false === $options){ // 用于子查询 不查询只返回SQL
                $options['fetch_sql'] = true;
            }
            // 分析表达式
            $options    =  $this->_parseOptions($options);
            // 判断查询缓存
            if(isset($options['cache'])){
                $cache  =   $options['cache'];
                $key    =   is_string($cache['key'])?$cache['key']:md5(serialize($options));
                $data   =   S($key,'',$cache);
                if(false !== $data){
                    return $data;
                }
            }        
            $resultSet  = $this->db->select($options);
            if(false === $resultSet) {
                return false;
            }
            if(!empty($resultSet)) { // 有查询结果
                if(is_string($resultSet)){
                    return $resultSet;
                }
    
                $resultSet  =   array_map(array($this,'_read_data'),$resultSet);
                $this->_after_select($resultSet,$options);
                if(isset($options['index'])){ // 对数据集进行索引
                    $index  =   explode(',',$options['index']);
                    foreach ($resultSet as $result){
                        $_key   =  $result[$index[0]];
                        if(isset($index[1]) && isset($result[$index[1]])){
                            $cols[$_key] =  $result[$index[1]];
                        }else{
                            $cols[$_key] =  $result;
                        }
                    }
                    $resultSet  =   $cols;
                }
            }
    
            if(isset($cache)){
                S($key,$resultSet,$cache);
            }
            return $resultSet;
        }
        // 查询成功后的回调方法
        protected function _after_select(&$resultSet,$options) {}
    
        /**
         * 生成查询SQL 可用于子查询
         * @access public
         * @return string
         */
        public function buildSql() {
            return  '( '.$this->fetchSql(true)->select().' )';
        }// 子查询 开始
    
    
    
    
    
        /**
         * 数据读取后的处理
         * @access protected
         * @param array $data 当前数据
         * @return array
         */
        protected function _read_data($data) {
            // 检查字段映射
            if(!empty($this->_map) && C('READ_DATA_MAP')) {
                foreach ($this->_map as $key=>$val){
                    if(isset($data[$val])) {
                        $data[$key] =   $data[$val];
                        unset($data[$val]);
                    }
                }
            }
            return $data;
        }// 数据读取后的处理。
    
        /**
         * 查询数据
         * @access public
         * @param mixed $options 表达式参数
         * @return mixed
         */
        public function find($options=array()) {
            if(is_numeric($options) || is_string($options)) {
                $where[$this->getPk()]  =   $options;
                $options                =   array();
                $options['where']       =   $where;
            }// 处理选项
            // 根据复合主键查找记录
            $pk  =  $this->getPk();// ID
            if (is_array($options) && (count($options) > 0) && is_array($pk)) {
                // 根据复合主键查询
                $count = 0;
                foreach (array_keys($options) as $key) {
                    if (is_int($key)) $count++; 
                } 
                if ($count == count($pk)) {
                    $i = 0;
                    foreach ($pk as $field) {
                        $where[$field] = $options[$i];
                        unset($options[$i++]);
                    }
                    $options['where']  =  $where;
                } else {
                    return false;
                }
            }
            // 开始 执行了
            // 总是查找一条记录
            $options['limit']   =   1;
            // 分析表达式
            $options            =   $this->_parseOptions($options);
            // 判断查询缓存
            if(isset($options['cache'])){
                $cache  =   $options['cache'];
                $key    =   is_string($cache['key'])?$cache['key']:md5(serialize($options));
                $data   =   S($key,'',$cache);
                if(false !== $data){
                    $this->data     =   $data;
                    return $data;
                }
            } // 还是 需要缓存
            $resultSet          =   $this->db->select($options);
            if(false === $resultSet) {
                return false;
            }
            if(empty($resultSet)) {// 查询结果为空
                return null;
            }
            if(is_string($resultSet)){
                return $resultSet;
            }
    
            // 读取数据后的处理
            $data   =   $this->_read_data($resultSet[0]);
            $this->_after_find($data,$options);
            if(!empty($this->options['result'])) {
                return $this->returnResult($data,$this->options['result']);
            }
            $this->data     =   $data;
            if(isset($cache)){
                S($key,$data,$cache);
            }
            return $this->data;
        }
        // 查询成功的回调方法
        protected function _after_find(&$result,$options) {}
    
        protected function returnResult($data,$type=''){
            if ($type){
                if(is_callable($type)){
                    return call_user_func($type,$data);
                }
                switch (strtolower($type)){
                    case 'json':
                        return json_encode($data);
                    case 'xml':
                        return xml_encode($data);
                }
            }
            return $data;
        }// 这里了 就是了
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
        /**
         * 处理字段映射
         * @access public
         * @param array $data 当前数据
         * @param integer $type 类型 0 写入 1 读取
         * @return array
         */
        public function parseFieldsMap($data,$type=1) {
            // 检查字段映射
            if(!empty($this->_map)) { // 已经有这个
                foreach ($this->_map as $key=>$val){ // 对变量进行 遍历
                    if($type==1) { // 读取
                        if(isset($data[$val])) {
                            $data[$key] =   $data[$val];
                            unset($data[$val]);
                        }
                    }else{ // 如果 写入
                        if(isset($data[$key])) {
                            $data[$val] =   $data[$key];
                            unset($data[$key]);
                        }
                    }
                }
            }
            return $data;
        }// 检查整理 合适 的 数据 映射
        // 评价:没什么了,没看懂
    
        /**
         * 设置记录的某个字段值
         * 支持使用数据库字段和方法
         * @access public
         * @param string|array $field  字段名
         * @param string $value  字段值
         * @return boolean
         */
        public function setField($field,$value='') {
            if(is_array($field)) {
                $data           =   $field;
            }else{
                $data[$field]   =   $value;
            }
            return $this->save($data);
        }
        // 搞了这个半天,就是弄个了 转存而已。
    
        /**
         * 字段值增长
         * @access public
         * @param string $field  字段名
         * @param integer $step  增长值
         * @param integer $lazyTime  延时时间(s)
         * @return boolean
         */
        public function setInc($field,$step=1,$lazyTime=0) {
            if($lazyTime>0) {// 延迟写入  获取对应 的开始 延迟写入
                $condition 	=  	$this->options['where'];
                $guid 		=  	md5($this->name.'_'.$field.'_'.serialize($condition));
                $step 		= 	$this->lazyWrite($guid,$step,$lazyTime);
                if(empty($step)) {
                    return true; // 等待下次写入
                }elseif($step < 0) {
                    $step 	=	'-'.$step;
                }
            }
            return $this->setField($field,array('exp',$field.'+'.$step)); // 设置了 上面的模版
        }// 获取 没什么鸟用,就是 更新了
    
        /**
         * 字段值减少
         * @access public
         * @param string $field  字段名
         * @param integer $step  减少值
         * @param integer $lazyTime  延时时间(s)
         * @return boolean
         */
        public function setDec($field,$step=1,$lazyTime=0) {
            if($lazyTime>0) {// 延迟写入
                $condition  =  	$this->options['where'];
                $guid 		=  	md5($this->name.'_'.$field.'_'.serialize($condition));
                $step 		= 	$this->lazyWrite($guid,-$step,$lazyTime);
                if(empty($step)) {
                    return true; // 等待下次写入
                }elseif($step > 0) {
                    $step 	=	'-'.$step;
                }
            }
            return $this->setField($field,array('exp',$field.'-'.$step));
        }// 同上 不加评论
    
        /**
         * 延时更新检查 返回false表示需要延时
         * 否则返回实际写入的数值
         * @access public
         * @param string $guid  写入标识
         * @param integer $step  写入步进值
         * @param integer $lazyTime  延时时间(s)
         * @return false|integer
         */
        protected function lazyWrite($guid,$step,$lazyTime) {
            if(false !== ($value = S($guid))) { // 存在缓存写入数据
                if(NOW_TIME > S($guid.'_time')+$lazyTime) {
                    // 延时更新时间到了,删除缓存数据 并实际写入数据库
                    S($guid,NULL);
                    S($guid.'_time',NULL);
                    return $value+$step;
                }else{
                    // 追加数据到缓存
                    S($guid,$value+$step);
                    return false;
                }
            }else{ // 没有缓存数据
                S($guid,$step);
                // 计时开始
                S($guid.'_time',NOW_TIME);
                return false;
            }
        }// 缓存处理
    
        /**
         * 获取一条记录的某个字段值
         * @access public
         * @param string $field  字段名
         * @param string $spea  字段数据间隔符号 NULL返回数组
         * @return mixed
         */
        public function getField($field,$sepa=null) {
            $options['field']       =   $field; // 字段开始
            $options                =   $this->_parseOptions($options); // 解析选项
            // 判断查询缓存
            if(isset($options['cache'])){ // 增加了 缓存优化
                $cache  =   $options['cache'];
                $key    =   is_string($cache['key'])?$cache['key']:md5($sepa.serialize($options));
                $data   =   S($key,'',$cache);
                if(false !== $data){
                    return $data;
                }
            }        
            $field                  =   trim($field); // 整理字段
            if(strpos($field,',') && false !== $sepa) { // 多字段
                if(!isset($options['limit'])){
                    $options['limit']   =   is_numeric($sepa)?$sepa:'';
                } // 居然还有 条数限制
                $resultSet          =   $this->db->select($options); // 还是 外包给这个家伙了
                if(!empty($resultSet)) { // 对返回的数据
                    if(is_string($resultSet)){
                        return $resultSet;
                    }               
                    $_field         =   explode(',', $field);// 私有变量
                    $field          =   array_keys($resultSet[0]); // 获取其 字段
                    $key1           =   array_shift($field);
                    $key2           =   array_shift($field);
                    $cols           =   array();
                    $count          =   count($_field);
                    foreach ($resultSet as $result){
                        $name   =  $result[$key1];
                        if(2==$count) {
                            $cols[$name]   =  $result[$key2];
                        }else{
                            $cols[$name]   =  is_string($sepa)?implode($sepa,array_slice($result,1)):$result;
                        }
                    }
                    if(isset($cache)){
                        S($key,$cols,$cache);// 保存 缓存数据
                    }
                    return $cols;// 返回结果
                }
            }else{   // 查找一条记录
                // 返回数据个数
                if(true !== $sepa) {// 当sepa指定为true的时候 返回所有数据
                    $options['limit']   =   is_numeric($sepa)?$sepa:1;
                }
                $result = $this->db->select($options); // 查询 外包
                if(!empty($result)) { // 有数据
                    if(is_string($result)){
                        return $result;
                    }               
                    if(true !== $sepa && 1==$options['limit']) {
                        $data   =   reset($result[0]);
                        if(isset($cache)){
                            S($key,$data,$cache);
                        }            
                        return $data;
                    }
                    foreach ($result as $val){
                        $array[]    =   $val[$field];
                    }
                    if(isset($cache)){
                        S($key,$array,$cache);
                    }                
                    return $array;
                }
            }
            return null;
        }// 这个比较长  用的比较多
    
        /**
         * 创建数据对象 但不保存到数据库
         * @access public
         * @param mixed $data 创建数据
         * @param string $type 状态
         * @return mixed
         */
         public function create($data='',$type='') {
            // 如果没有传值默认取POST数据
            if(empty($data)) {
                $data   =   I('post.'); // 哥哥,你这个好粗暴呢
            }elseif(is_object($data)){
                $data   =   get_object_vars($data); //返回由 obj 指定的对象中定义的属性组成的关联数组。
            }
            // 验证数据
            if(empty($data) || !is_array($data)) {// 如果数据有问题
                $this->error = L('_DATA_TYPE_INVALID_');
                return false;
            }
    
            // 状态
            $type = $type?:(!empty($data[$this->getPk()])?self::MODEL_UPDATE:self::MODEL_INSERT);
             // 这里的不同 状态 对应的代码 跟 不一样。
    
            // 检查字段映射
            $data =	$this->parseFieldsMap($data,0);
    
            // 检测提交字段的合法性
            if(isset($this->options['field'])) { // $this->field('field1,field2...')->create()
                $fields =   $this->options['field'];
                unset($this->options['field']);
            }elseif($type == self::MODEL_INSERT && isset($this->insertFields)) {
                $fields =   $this->insertFields;
            }elseif($type == self::MODEL_UPDATE && isset($this->updateFields)) {
                $fields =   $this->updateFields;
            }
            if(isset($fields)) { // 对 这个
                if(is_string($fields)) {
                    $fields =   explode(',',$fields);
                }
                // 判断令牌验证字段
                if(C('TOKEN_ON'))   $fields[] = C('TOKEN_NAME', null, '__hash__');
                foreach ($data as $key=>$val){
                    if(!in_array($key,$fields)) {
                        unset($data[$key]);
                    }
                }
            }
    
            // 数据自动验证
            if(!$this->autoValidation($data,$type)) return false;
    
            // 表单令牌验证
            if(!$this->autoCheckToken($data)) {
                $this->error = L('_TOKEN_ERROR_');
                return false;
            }
    
            // 验证完成生成数据对象
            if($this->autoCheckFields) { // 开启字段检测 则过滤非法字段数据
                $fields =   $this->getDbFields(); // 获取数据 开始
                foreach ($data as $key=>$val){
                    if(!in_array($key,$fields)) {
                        unset($data[$key]);
                    }elseif(MAGIC_QUOTES_GPC && is_string($val)){
                        $data[$key] =   stripslashes($val);
                    }
                }
            }
    
            // 创建完成对数据进行自动处理
            $this->autoOperation($data,$type);
            // 赋值当前数据对象
            $this->data =   $data;
            // 返回创建的数据以供其他调用
            return $data;
         }// 创建 数据
        // 把数据 处理出来 完善
    
        // 自动表单令牌验证
        // TODO  ajax无刷新多次提交暂不能满足
        public function autoCheckToken($data) {
            // 支持使用token(false) 关闭令牌验证
            if(isset($this->options['token']) && !$this->options['token']) return true; // 直接 给ok了
            if(C('TOKEN_ON')){
                $name   = C('TOKEN_NAME', null, '__hash__');
                if(!isset($data[$name]) || !isset($_SESSION[$name])) { // 令牌数据无效
                    return false;
                }
    
                // 令牌验证
                list($key,$value)  =  explode('_',$data[$name]);
                if(isset($_SESSION[$name][$key]) && $value && $_SESSION[$name][$key] === $value) { // 防止重复提交
                    unset($_SESSION[$name][$key]); // 验证完成销毁session
                    return true;
                }
                // 开启TOKEN重置
                if(C('TOKEN_RESET')) unset($_SESSION[$name][$key]);
                return false;
            }
            return true;
        }// 就是对比 session 里面的 token 里面的代码
    
        /**
         * 使用正则验证数据
         * @access public
         * @param string $value  要验证的数据
         * @param string $rule 验证规则
         * @return boolean
         */
        public function regex($value,$rule) {
            $validate = array(
                'require'   =>  '/\S+/',
                'email'     =>  '/^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/',
                'url'       =>  '/^http(s?):\/\/(?:[A-za-z0-9-]+\.)+[A-za-z]{2,4}(:\d+)?(?:[\/\?#][\/=\?%\-&~`@[\]\':+!\.#\w]*)?$/',
                'currency'  =>  '/^\d+(\.\d+)?$/',
                'number'    =>  '/^\d+$/',
                'zip'       =>  '/^\d{6}$/',
                'integer'   =>  '/^[-\+]?\d+$/',
                'double'    =>  '/^[-\+]?\d+(\.\d+)?$/',
                'english'   =>  '/^[A-Za-z]+$/',
            );
            // 检查是否有内置的正则表达式
            if(isset($validate[strtolower($rule)]))
                $rule       =   $validate[strtolower($rule)];
            return preg_match($rule,$value)===1;
        }// 正则匹配
    
        /**
         * 自动表单处理
         * @access public
         * @param array $data 创建数据
         * @param string $type 创建类型
         * @return mixed
         */
        private function autoOperation(&$data,$type) {
            if(false === $this->options['auto']){
                // 关闭自动完成
                return $data;
            }
            if(!empty($this->options['auto'])) {
                $_auto   =   $this->options['auto'];
                unset($this->options['auto']);
            }elseif(!empty($this->_auto)){
                $_auto   =   $this->_auto;
            }
            // 自动填充
            if(isset($_auto)) {
                foreach ($_auto as $auto){
                    // 填充因子定义格式
                    // array('field','填充内容','填充条件','附加规则',[额外参数])
                    if(empty($auto[2])) $auto[2] =  self::MODEL_INSERT; // 默认为新增的时候自动填充
                    if( $type == $auto[2] || $auto[2] == self::MODEL_BOTH) {
                        if(empty($auto[3])) $auto[3] =  'string';
                        switch(trim($auto[3])) {
                            case 'function':    //  使用函数进行填充 字段的值作为参数
                            case 'callback': // 使用回调方法
                                $args = isset($auto[4])?(array)$auto[4]:array();
                                if(isset($data[$auto[0]])) {
                                    array_unshift($args,$data[$auto[0]]);
                                }
                                if('function'==$auto[3]) {
                                    $data[$auto[0]]  = call_user_func_array($auto[1], $args);
                                }else{
                                    $data[$auto[0]]  =  call_user_func_array(array(&$this,$auto[1]), $args);
                                }
                                break;
                            case 'field':    // 用其它字段的值进行填充
                                $data[$auto[0]] = $data[$auto[1]];
                                break;
                            case 'ignore': // 为空忽略
                                if($auto[1]===$data[$auto[0]])
                                    unset($data[$auto[0]]);
                                break;
                            case 'string':
                            default: // 默认作为字符串填充
                                $data[$auto[0]] = $auto[1];
                        }
                        if(isset($data[$auto[0]]) && false === $data[$auto[0]] )   unset($data[$auto[0]]);
                    }
                }
            }
            return $data;
        }// auto 里面的 写法 针对性处理。
    
        /**
         * 自动表单验证
         * @access protected
         * @param array $data 创建数据
         * @param string $type 创建类型
         * @return boolean
         */
        protected function autoValidation($data,$type) {
            if(false === $this->options['validate'] ){
                // 关闭自动验证
                return true;
            }
            if(!empty($this->options['validate'])) {
                $_validate   =   $this->options['validate'];
                unset($this->options['validate']);
            }elseif(!empty($this->_validate)){
                $_validate   =   $this->_validate;
            }
            // 属性验证
            if(isset($_validate)) { // 如果设置了数据自动验证则进行数据验证
                if($this->patchValidate) { // 重置验证错误信息
                    $this->error = array();
                }
                foreach($_validate as $key=>$val) {
                    // 验证因子定义格式
                    // array(field,rule,message,condition,type,when,params)
                    // 判断是否需要执行验证
                    if(empty($val[5]) || ( $val[5]== self::MODEL_BOTH && $type < 3 ) || $val[5]== $type ) {
                        if(0==strpos($val[2],'{%') && strpos($val[2],'}'))
                            // 支持提示信息的多语言 使用 {%语言定义} 方式
                            $val[2]  =  L(substr($val[2],2,-1));
                        $val[3]  =  isset($val[3])?$val[3]:self::EXISTS_VALIDATE;
                        $val[4]  =  isset($val[4])?$val[4]:'regex';
                        // 判断验证条件
                        switch($val[3]) {
                            case self::MUST_VALIDATE:   // 必须验证 不管表单是否有设置该字段
                                if(false === $this->_validationField($data,$val)) 
                                    return false;
                                break;
                            case self::VALUE_VALIDATE:    // 值不为空的时候才验证
                                if('' != trim($data[$val[0]]))
                                    if(false === $this->_validationField($data,$val)) 
                                        return false;
                                break;
                            default:    // 默认表单存在该字段就验证
                                if(isset($data[$val[0]]))
                                    if(false === $this->_validationField($data,$val)) 
                                        return false;
                        }
                    }
                }
                // 批量验证的时候最后返回错误
                if(!empty($this->error)) return false;
            }
            return true;
        } // 自动验证
    
        /**
         * 验证表单字段 支持批量验证
         * 如果批量验证返回错误的数组信息
         * @access protected
         * @param array $data 创建数据
         * @param array $val 验证因子
         * @return boolean
         */
        protected function _validationField($data,$val) {
            if($this->patchValidate && isset($this->error[$val[0]]))
                return ; //当前字段已经有规则验证没有通过
            if(false === $this->_validationFieldItem($data,$val)){
                if($this->patchValidate) {
                    $this->error[$val[0]]   =   $val[2];
                }else{
                    $this->error            =   $val[2];
                    return false;
                }
            }
            return ;
        }
    
        /**
         * 根据验证因子验证字段
         * @access protected
         * @param array $data 创建数据
         * @param array $val 验证因子
         * @return boolean
         */
        protected function _validationFieldItem($data,$val) {
            switch(strtolower(trim($val[4]))) {
                case 'function':// 使用函数进行验证
                case 'callback':// 调用方法进行验证
                    $args = isset($val[6])?(array)$val[6]:array();
                    if(is_string($val[0]) && strpos($val[0], ','))
                        $val[0] = explode(',', $val[0]);
                    if(is_array($val[0])){
                        // 支持多个字段验证
                        foreach($val[0] as $field)
                            $_data[$field] = $data[$field];
                        array_unshift($args, $_data);
                    }else{
                        array_unshift($args, $data[$val[0]]);
                    }
                    if('function'==$val[4]) {
                        return call_user_func_array($val[1], $args);
                    }else{
                        return call_user_func_array(array(&$this, $val[1]), $args);
                    }
                case 'confirm': // 验证两个字段是否相同
                    return $data[$val[0]] == $data[$val[1]];
                case 'unique': // 验证某个值是否唯一
                    if(is_string($val[0]) && strpos($val[0],','))
                        $val[0]  =  explode(',',$val[0]);
                    $map = array();
                    if(is_array($val[0])) {
                        // 支持多个字段验证
                        foreach ($val[0] as $field)
                            $map[$field]   =  $data[$field];
                    }else{
                        $map[$val[0]] = $data[$val[0]];
                    }
                    $pk =   $this->getPk();
                    if(!empty($data[$pk]) && is_string($pk)) { // 完善编辑的时候验证唯一
                        $map[$pk] = array('neq',$data[$pk]);
                    }
                    if($this->where($map)->find())   return false;
                    return true;
                default:  // 检查附加规则
                    return $this->check($data[$val[0]],$val[1],$val[4]);
            }
        } // 验证代码
    
        /**
         * 验证数据 支持 in between equal length regex expire ip_allow ip_deny
         * @access public
         * @param string $value 验证数据
         * @param mixed $rule 验证表达式
         * @param string $type 验证方式 默认为正则验证
         * @return boolean
         */
        public function check($value,$rule,$type='regex'){
            $type   =   strtolower(trim($type));
            switch($type) {
                case 'in': // 验证是否在某个指定范围之内 逗号分隔字符串或者数组
                case 'notin':
                    $range   = is_array($rule)? $rule : explode(',',$rule);
                    return $type == 'in' ? in_array($value ,$range) : !in_array($value ,$range);
                case 'between': // 验证是否在某个范围
                case 'notbetween': // 验证是否不在某个范围            
                    if (is_array($rule)){
                        $min    =    $rule[0];
                        $max    =    $rule[1];
                    }else{
                        list($min,$max)   =  explode(',',$rule);
                    }
                    return $type == 'between' ? $value>=$min && $value<=$max : $value<$min || $value>$max;
                case 'equal': // 验证是否等于某个值
                case 'notequal': // 验证是否等于某个值            
                    return $type == 'equal' ? $value == $rule : $value != $rule;
                case 'length': // 验证长度
                    $length  =  mb_strlen($value,'utf-8'); // 当前数据长度
                    if(strpos($rule,',')) { // 长度区间
                        list($min,$max)   =  explode(',',$rule);
                        return $length >= $min && $length <= $max;
                    }else{// 指定长度
                        return $length == $rule;
                    }
                case 'expire':
                    list($start,$end)   =  explode(',',$rule);
                    if(!is_numeric($start)) $start   =  strtotime($start);
                    if(!is_numeric($end)) $end   =  strtotime($end);
                    return NOW_TIME >= $start && NOW_TIME <= $end;
                case 'ip_allow': // IP 操作许可验证
                    return in_array(get_client_ip(),explode(',',$rule));
                case 'ip_deny': // IP 操作禁止验证
                    return !in_array(get_client_ip(),explode(',',$rule));
                case 'regex':
                default:    // 默认使用正则验证 可以使用验证类中定义的验证名称
                    // 检查附加规则
                    return $this->regex($value,$rule);
            }
        }// 验证 对应的 代码
    
        /**
         * 存储过程返回多数据集
         * @access public
         * @param string $sql  SQL指令
         * @param mixed $parse  是否需要解析SQL
         * @return array
         */
        public function procedure($sql, $parse = false) {
            return $this->db->procedure($sql, $parse);
        }// 封包
    
        /**
         * SQL查询
         * @access public
         * @param string $sql  SQL指令
         * @param mixed $parse  是否需要解析SQL
         * @return mixed
         */
        public function query($sql,$parse=false) {
            if(!is_bool($parse) && !is_array($parse)) {
                $parse = func_get_args();
                array_shift($parse);
            }
            $sql  =   $this->parseSql($sql,$parse);
            return $this->db->query($sql);
        } // 解析 执行 代码
    
        /**
         * 执行SQL语句
         * @access public
         * @param string $sql  SQL指令
         * @param mixed $parse  是否需要解析SQL
         * @return false | integer
         */
        public function execute($sql,$parse=false) {
            if(!is_bool($parse) && !is_array($parse)) {
                $parse = func_get_args();
                array_shift($parse);
            }
            $sql  =   $this->parseSql($sql,$parse);
            return $this->db->execute($sql);
        }
    
        /**
         * 解析SQL语句
         * @access public
         * @param string $sql  SQL指令
         * @param boolean $parse  是否需要解析SQL
         * @return string
         */
        protected function parseSql($sql,$parse) {
            // 分析表达式
            if(true === $parse) {
                $options =  $this->_parseOptions();
                $sql    =   $this->db->parseSql($sql,$options);
            }elseif(is_array($parse)){ // SQL预处理
                $parse  =   array_map(array($this->db,'escapeString'),$parse);
                $sql    =   vsprintf($sql,$parse);
            }else{
                $sql    =   strtr($sql,array('__TABLE__'=>$this->getTableName(),'__PREFIX__'=>$this->tablePrefix));
                $prefix =   $this->tablePrefix;
                $sql    =   preg_replace_callback("/__([A-Z0-9_-]+)__/sU", function($match) use($prefix){ return $prefix.strtolower($match[1]);}, $sql);
            }
            $this->db->setModel($this->name);
            return $sql;
        }// 生成合适的 sql 语句了
    
    
    
    
    
    
    
    
        /**
         * 启动事务
         * @access public
         * @return void
         */
        public function startTrans() {
            $this->commit();
            $this->db->startTrans();
            return ;
        }
    
        /**
         * 提交事务
         * @access public
         * @return boolean
         */
        public function commit() {
            return $this->db->commit();
        }
    
        /**
         * 事务回滚
         * @access public
         * @return boolean
         */
        public function rollback() {
            return $this->db->rollback();
        }
    
        /**
         * 返回模型的错误信息
         * @access public
         * @return string
         */
        public function getError(){
            return $this->error;
        }
    
        /**
         * 返回数据库的错误信息
         * @access public
         * @return string
         */
        public function getDbError() {
            return $this->db->getError();
        }
    
        /**
         * 返回最后插入的ID
         * @access public
         * @return string
         */
        public function getLastInsID() {
            return $this->db->getLastInsID();
        }
    
        /**
         * 返回最后执行的sql语句
         * @access public
         * @return string
         */
        public function getLastSql() {
            return $this->db->getLastSql($this->name);
        }
        // 鉴于getLastSql比较常用 增加_sql 别名
        public function _sql(){
            return $this->getLastSql();
        }
    
        /**
         * 获取主键名称
         * @access public
         * @return string
         */
        public function getPk() {
            return $this->pk;
        }
    
        /**
         * 获取数据表字段信息
         * @access public
         * @return array
         */
        public function getDbFields(){
            if(isset($this->options['table'])) {// 动态指定表名
                if(is_array($this->options['table'])){
                    $table  =   key($this->options['table']);
                }else{
                    $table  =   $this->options['table'];
                    if(strpos($table,')')){
                        // 子查询
                        return false;
                    }
                }
                $fields     =   $this->db->getFields($table);
                return  $fields ? array_keys($fields) : false;
            }
            if($this->fields) {
                $fields     =  $this->fields;
                unset($fields['_type'],$fields['_pk']);
                return $fields;
            }
            return false;
        }
    
        /**
         * 设置数据对象值
         * @access public
         * @param mixed $data 数据
         * @return Model
         */
        public function data($data=''){
            if('' === $data && !empty($this->data)) {
                return $this->data;
            }
            if(is_object($data)){
                $data   =   get_object_vars($data);
            }elseif(is_string($data)){
                parse_str($data,$data);
            }elseif(!is_array($data)){
                E(L('_DATA_TYPE_INVALID_'));
            }
            $this->data = $data;
            return $this;
        }// 设置 数据
    
        /**
         * 指定当前的数据表
         * @access public
         * @param mixed $table
         * @return Model
         */
        public function table($table) {
            $prefix =   $this->tablePrefix;
            if(is_array($table)) {
                $this->options['table'] =   $table;
            }elseif(!empty($table)) {
                //将__TABLE_NAME__替换成带前缀的表名
                $table  = preg_replace_callback("/__([A-Z0-9_-]+)__/sU", function($match) use($prefix){ return $prefix.strtolower($match[1]);}, $table);
                $this->options['table'] =   $table;
            }
            return $this;
        } // 设置表名
    
        /**
         * USING支持 用于多表删除
         * @access public
         * @param mixed $using
         * @return Model
         */
        public function using($using){
            $prefix =   $this->tablePrefix;
            if(is_array($using)) {
                $this->options['using'] =   $using;
            }elseif(!empty($using)) {
                //将__TABLE_NAME__替换成带前缀的表名
                $using  = preg_replace_callback("/__([A-Z0-9_-]+)__/sU", function($match) use($prefix){ return $prefix.strtolower($match[1]);}, $using);
                $this->options['using'] =   $using;
            }
            return $this;
        } // 很少用
    
        /**
         * 查询SQL组装 join
         * @access public
         * @param mixed $join
         * @param string $type JOIN类型
         * @return Model
         */
        public function join($join,$type='INNER') {
            $prefix =   $this->tablePrefix;
            if(is_array($join)) {
                foreach ($join as $key=>&$_join){
                    $_join  =   preg_replace_callback("/__([A-Z0-9_-]+)__/sU", function($match) use($prefix){ return $prefix.strtolower($match[1]);}, $_join);
                    $_join  =   false !== stripos($_join,'JOIN')? $_join : $type.' JOIN ' .$_join;
                }
                $this->options['join']      =   $join;
            }elseif(!empty($join)) {
                //将__TABLE_NAME__字符串替换成带前缀的表名
                $join  = preg_replace_callback("/__([A-Z0-9_-]+)__/sU", function($match) use($prefix){ return $prefix.strtolower($match[1]);}, $join);
                $this->options['join'][]    =   false !== stripos($join,'JOIN')? $join : $type.' JOIN '.$join;
            }
            return $this;
        } // 联合查询
    
        /**
         * 查询SQL组装 union
         * @access public
         * @param mixed $union
         * @param boolean $all
         * @return Model
         */
        public function union($union,$all=false) {
            if(empty($union)) return $this;
            if($all) {
                $this->options['union']['_all']  =   true;
            }
            if(is_object($union)) {
                $union   =  get_object_vars($union);
            }
            // 转换union表达式
            if(is_string($union) ) {
                $prefix =   $this->tablePrefix;
                //将__TABLE_NAME__字符串替换成带前缀的表名
                $options  = preg_replace_callback("/__([A-Z0-9_-]+)__/sU", function($match) use($prefix){ return $prefix.strtolower($match[1]);}, $union);
            }elseif(is_array($union)){
                if(isset($union[0])) {
                    $this->options['union']  =  array_merge($this->options['union'],$union);
                    return $this;
                }else{
                    $options =  $union;
                }
            }else{
                E(L('_DATA_TYPE_INVALID_'));
            }
            $this->options['union'][]  =   $options;
            return $this;
        }
    
        /**
         * 查询缓存
         * @access public
         * @param mixed $key
         * @param integer $expire
         * @param string $type
         * @return Model
         */
        public function cache($key=true,$expire=null,$type=''){
            // 增加快捷调用方式 cache(10) 等同于 cache(true, 10)
            if(is_numeric($key) && is_null($expire)){
                $expire = $key;
                $key    = true;
            }
            if(false !== $key)
                $this->options['cache']  =  array('key'=>$key,'expire'=>$expire,'type'=>$type);
            return $this;
        } // 缓存选项
    
        /**
         * 指定查询字段 支持字段排除
         * @access public
         * @param mixed $field
         * @param boolean $except 是否排除
         * @return Model
         */
        public function field($field,$except=false){
            if(true === $field) {// 获取全部字段
                $fields     =  $this->getDbFields();
                $field      =  $fields?:'*';
            }elseif($except) {// 字段排除
                if(is_string($field)) {
                    $field  =  explode(',',$field);
                }
                $fields     =  $this->getDbFields();
                $field      =  $fields?array_diff($fields,$field):$field;
            }
            $this->options['field']   =   $field;
            return $this;
        }// 设置字段
    
        /**
         * 调用命名范围
         * @access public
         * @param mixed $scope 命名范围名称 支持多个 和直接定义
         * @param array $args 参数
         * @return Model
         */PHP编程
            

    郑重声明:本文版权归原作者所有,转载文章仅为传播更多信息之目的,如作者信息标记有误,请第一时间联系我们修改或删除,多谢。

  • 相关文章阅读