摘要：模型類實現了和模式操作狀態插入模型數據更新模型數據包含上面兩種方式必須驗證表單存在字段則驗證表單值不為空則驗證當前使用的擴展模型當前數據庫操作對象主鍵名稱數據表前綴模型名稱數據庫名稱數據庫配置數據表名不包含表前綴實際數據表名包含表前綴最近錯
/**
* ThinkPHP Model模型類
* 實現了ORM和ActiveRecords模式
* @category Think
* @package Think
* @subpackage Core
* @author liu21st
*/
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;// 表單值不為空則驗證
// 當前使用的擴展模型
private $_extModel = null;
// 當前數據庫操作對象
protected $db = null;
// 主鍵名稱
protected $pk = "id";
// 數據表前綴
protected $tablePrefix = "";
// 模型名稱
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("table","order","alias","having","group","lock","distinct","auto","filter","validate");
/**
* 架構函數
* 取得DB類的實例對象 字段檢查
* @access public
* @param string $name 模型名稱
* @param string $tablePrefix 表前綴
* @param mixed $connection 數據庫連接信息
*/
public function __construct($name="",$tablePrefix="",$connection="") {
// 模型初始化
$this->_initialize();
// 獲取模型名稱
if(!empty($name)) {
if(strpos($name,".")) { // 支持 數據庫名.模型名的 定義
//屬性1-數據庫名 屬性2-模型表名(數據表名)
list($this->dbName,$this->name) = explode(".",$name);
}else{//模型名
$this->name = $name;
}
}elseif(empty($this->name)){
//模型名為空的情況
$this->name = $this->getModelName();
}
// 設置表前綴，檢查$tablePrefix表前綴參數是否為Null，注意：不是檢查表前綴參數是否為空
if(is_null($tablePrefix)) {// 如果表前綴參數為Null表示沒有前綴
$this->tablePrefix = "";//沒有前綴的情況
}elseif("" != $tablePrefix) {//如果表前綴參數不為空
$this->tablePrefix = $tablePrefix;
}else{
//默認執行：如果類中未指定表前綴，那么將采用系統默認指定的表前綴
$this->tablePrefix = $this->tablePrefix?$this->tablePrefix:C("DB_PREFIX");
}
// 數據庫初始化操作
// 獲取數據庫操作對象
// 當前模型有獨立的數據庫連接信息
$this->db(0,empty($this->connection)?$connection:$this->connection);
}
/**
* 自動檢測數據表信息
* @access protected
* @return void
*/
protected function _checkTableInfo() {
// 如果不是Model類 自動記錄數據表信息
// 只在第一次執行記錄
if(empty($this->fields)) {//默認執行
// 如果數據表字段沒有定義則自動獲取
//調試模式下不執行
if(C("DB_FIELDS_CACHE")) {//字段緩存的啟用
$db = $this->dbName?$this->dbName:C("DB_NAME");//數據庫名
$fields = F("_fields/".strtolower($db.".".$this->name));
if($fields) {
$version = C("DB_FIELD_VERISON");
if(empty($version) || $fields["_version"]== $version) {
$this->fields = $fields;
return ;
}
}
}
// 每次都會讀取數據表信息
$this->flush();
}
}
/**
* 獲取字段信息并緩存
* @access public
* @return void
*/
public function flush() {
//$this->db:數據庫驅動類Db,class.php實例化對象，查看$this->db()方法
// 緩存不存在則查詢數據表信息
//var_dump($this->db);//DbMysql.class.php驅動類對象
//setModel()方法為Db.class.php中方法
//class DbMysql extends Db{}
$this->db->setModel($this->name);
//$this->getTableName():獲取表名,如：think_user
//getFields方法獲取數據表每個字段的信息
/**
*[id] => Array(
* [name] => id
* [type] => smallint(4) unsigned
* [notnull] =>
* [default] =>
* [primary] => 1
* [autoinc] => 1
* )
*/
$fields = $this->db->getFields($this->getTableName());
if(!$fields) { // 無法獲取字段信息
return false;
}
/**
* Array(
* [0] => id
* [1] => title
* [2] => content
* [3] => create_time
* )
*/
$this->fields = array_keys($fields);
$this->fields["_autoinc"] = false;
//注意：循環的不是$this->fields
foreach ($fields as $key=>$val){
// 記錄字段類型
$type[$key] = $val["type"];//如：$type[id]=int
if($val["primary"]) {
$this->fields["_pk"] = $key;//主鍵字段，這里的$key為字段名
if($val["autoinc"]) $this->fields["_autoinc"] = true;//自動增長
}
}
// 記錄字段類型信息
$this->fields["_type"] = $type;//表中各個字段的類型
if(C("DB_FIELD_VERISON")) $this->fields["_version"] = C("DB_FIELD_VERISON");
// 2008-3-7 增加緩存開關控制
//調試模式下，為禁用，即：不會緩存
if(C("DB_FIELDS_CACHE")){
// 永久緩存數據表信息
$db = $this->dbName?$this->dbName:C("DB_NAME");
F("_fields/".strtolower($db.".".$this->name),$this->fields);
}
}
/**
* 設置數據對象的值
* @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{
throw_exception(__CLASS__.":".$method.L("_METHOD_NOT_EXIST_"));
return;
}
}
// 回調方法 初始化模型
protected function _initialize() {}
/**
* 對保存到數據庫的數據進行處理
* @access protected
* @param mixed $data 要操作的數據
* @return boolean
*/
protected function _facade($data) {
// 檢查非數據字段
if(!empty($this->fields)) {
foreach ($data as $key=>$val){
if(!in_array($key,$this->fields,true)){
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) {}
/**
* 新增數據
* @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;
}
}
// 分析表達式
$options = $this->_parseOptions($options);
// 數據處理
$data = $this->_facade($data);//對保存到數據庫中的數據進行處理
if(false === $this->_before_insert($data,$options)) {
return false;
}
// 寫入數據到數據庫
/**
* $options:默認值有下面兩個
* Array
(
[table] => think_form
[model] => Form
)
*/
$result = $this->db->insert($data,$options,$replace);
if(false !== $result ) {
$insertId = $this->getLastInsID();
if($insertId) {
// 自增主鍵返回插入ID
$data[$this->getPk()] = $insertId;
$this->_after_insert($data,$options);
return $insertId;
}
$this->_after_insert($data,$options);
}
return $result;
}
// 插入數據前的回調方法
protected function _before_insert(&$data,$options) {}
// 插入成功后的回調方法
protected function _after_insert($data,$options) {}
public function addAll($dataList,$options=array(),$replace=false){
if(empty($dataList)) {
$this->error = L("_DATA_TYPE_INVALID_");
return false;
}
// 分析表達式
$options = $this->_parseOptions($options);
// 數據處理
foreach ($dataList as $key=>$data){
$dataList[$key] = $this->_facade($data);
}
// 寫入數據到數據庫
$result = $this->db->insertAll($dataList,$options,$replace);
if(false !== $result ) {
$insertId = $this->getLastInsID();
if($insertId) {
return $insertId;
}
}
return $result;
}
/**
* 通過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?$fields:$options["field"],$table?$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);
// 分析表達式
$options = $this->_parseOptions($options);
if(false === $this->_before_update($data,$options)) {
return false;
}
if(!isset($options["where"]) ) {
// 如果存在主鍵數據 則自動作為更新條件
if(isset($data[$this->getPk()])) {
$pk = $this->getPk();
$where[$pk] = $data[$pk];
$options["where"] = $where;
$pkValue = $data[$pk];
unset($data[$pk]);
}else{
// 如果沒有任何更新條件則不執行
$this->error = L("_OPERATION_WRONG_");
return false;
}
}
$result = $this->db->update($data,$options);
if(false !== $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()) {
if(empty($options) && empty($this->options["where"])) {
// 如果刪除條件為空 則刪除當前數據對象所對應的記錄
if(!empty($this->data) && isset($this->data[$this->getPk()]))
return $this->delete($this->data[$this->getPk()]);
else
return false;
}
if(is_numeric($options) || is_string($options)) {
// 根據主鍵刪除記錄
$pk = $this->getPk();
if(strpos($options,",")) {
$where[$pk] = array("IN", $options);
}else{
$where[$pk] = $options;
}
$pkValue = $where[$pk];
$options = array();
$options["where"] = $where;
}
// 分析表達式
$options = $this->_parseOptions($options);
$result= $this->db->delete($options);
if(false !== $result) {
$data = array();
if(isset($pkValue)) $data[$pk] = $pkValue;
$this->_after_delete($data,$options);
}
// 返回刪除記錄個數
return $result;
}
// 刪除成功后的回調方法
protected function _after_delete($data,$options) {}
/**
* 查詢數據集
* @access public
* @param array $options 表達式參數
* @return mixed
*/
public function select($options=array()) {
if(is_string($options) || is_numeric($options)) {
// 根據主鍵查詢
$pk = $this->getPk();
if(strpos($options,",")) {
$where[$pk] = array("IN",$options);
}else{
$where[$pk] = $options;
}
$options = array();
$options["where"] = $where;
}elseif(false === $options){ // 用于子查詢 不查詢只返回SQL
$options = array();
// 分析表達式
$options = $this->_parseOptions($options);
return "( ".$this->db->buildSelectSql($options)." )";
}
// 分析表達式
$options = $this->_parseOptions($options);
$resultSet = $this->db->select($options);
if(false === $resultSet) {
return false;
}
if(empty($resultSet)) { // 查詢結果為空
return null;
}
$this->_after_select($resultSet,$options);
return $resultSet;
}
// 查詢成功后的回調方法
protected function _after_select(&$resultSet,$options) {}
/**
* 生成查詢SQL 可用于子查詢
* @access public
* @param array $options 表達式參數
* @return string
*/
public function buildSql($options=array()) {
// 分析表達式
$options = $this->_parseOptions($options);
return "( ".$this->db->buildSelectSql($options)." )";
}
/**
* 分析表達式
* @access proteced
* @param array $options 表達式參數
* @return array
*/
protected function _parseOptions($options=array()) {
if(is_array($options))
$options = array_merge($this->options,$options);
// 查詢過后清空sql表達式組裝 避免影響下次查詢
$this->options = array();
if(!isset($options["table"]))
// 自動獲取表名
$options["table"] = $this->getTableName();
if(!empty($options["alias"])) {
$options["table"] .= " ".$options["alias"];
}
// 記錄操作的模型名稱
$options["model"] = $this->name;
// 字段類型驗證
if(isset($options["where"]) && is_array($options["where"]) && !empty($this->fields)) {
// 對數組查詢條件進行字段類型檢查
foreach ($options["where"] as $key=>$val){
$key = trim($key);
if(in_array($key,$this->fields,true)){
if(is_scalar($val)) {
$this->_parseType($options["where"],$key);
}
}elseif("_" != substr($key,0,1) && false === strpos($key,".") && false === strpos($key,"|") && false === strpos($key,"&")){
unset($options["where"][$key]);
}
}
}
// 表達式過濾
$this->_options_filter($options);
return $options;
}
// 表達式過濾回調方法
protected function _options_filter(&$options) {}
/**
* 數據類型檢測
* @access protected
* @param mixed $data 數據
* @param string $key 字段名
* @return void
*/
protected function _parseType(&$data,$key) {
$fieldType = strtolower($this->fields["_type"][$key]);
if(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 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;
}
// 總是查找一條記錄
$options["limit"] = 1;
// 分析表達式
$options = $this->_parseOptions($options);
$resultSet = $this->db->select($options);
if(false === $resultSet) {
return false;
}
if(empty($resultSet)) {// 查詢結果為空
return null;
}
$this->data = $resultSet[0];
$this->_after_find($this->data,$options);
return $this->data;
}
// 查詢成功的回調方法
protected function _after_find(&$result,$options) {}
/**
* 處理字段映射
* @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 增長值
* @return boolean
*/
public function setInc($field,$step=1) {
return $this->setField($field,array("exp",$field."+".$step));
}
/**
* 字段值減少
* @access public
* @param string $field 字段名
* @param integer $step 減少值
* @return boolean
*/
public function setDec($field,$step=1) {
return $this->setField($field,array("exp",$field."-".$step));
}
/**
* 獲取一條記錄的某個字段值
* @access public
* @param string $field 字段名
* @param string $spea 字段數據間隔符號 NULL返回數組
* @return mixed
*/
public function getField($field,$sepa=null) {
$options["field"] = $field;
$options = $this->_parseOptions($options);
$field = trim($field);
if(strpos($field,",")) { // 多字段
$options["limit"] = is_numeric($sepa)?$sepa:"";
$resultSet = $this->db->select($options);
if(!empty($resultSet)) {
$_field = explode(",", $field);
$field = array_keys($resultSet[0]);
$key = array_shift($field);
$key2 = array_shift($field);
$cols = array();
$count = count($_field);
foreach ($resultSet as $result){
$name = $result[$key];
if(2==$count) {
$cols[$name] = $result[$key2];
}else{
$cols[$name] = is_string($sepa)?implode($sepa,array_slice($result,1)):$result;
}
}
return $cols;
}
}else{ // 查找一條記錄
// 返回數據個數
if(true !== $sepa) {// 當sepa指定為true的時候 返回所有數據
$options["limit"] = is_numeric($sepa)?$sepa:1;
}
$result = $this->db->select($options);
if(!empty($result)) {
if(true !== $sepa && 1==$options["limit"]) return reset($result[0]);
foreach ($result as $val){
$array[] = $val[$field];
}
return $array;
}
}
return null;
}
/**
* 創建數據對象 但不保存到數據庫，數據對象就是指的Model.class.php類中的$data屬性
* @access public
* @param mixed $data 創建數據
* @param string $type 狀態
* @return mixed
*/
public function create($data="",$type="") {
// 如果沒有傳值默認取POST數據
if(empty($data)) {
$data = $_POST;//自動獲取$_POST過來的表單數據
}elseif(is_object($data)){
$data = get_object_vars($data);
}
// 驗證數據
if(empty($data) || !is_array($data)) {
$this->error = L("_DATA_TYPE_INVALID_");
return false;
}
// 檢查字段映射
$data = $this->parseFieldsMap($data,0);//參數2：0-寫入 1-讀取
// 狀態:1-插入模型數據
$type = $type?$type:(!empty($data[$this->getPk()])?self::MODEL_UPDATE:self::MODEL_INSERT);
// 檢測提交字段的合法性，適用于$this->field("field1,field2...")->create()情況
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->insert_fields)) {
$fields = $this->insert_fields;
}elseif($type == self::MODEL_UPDATE && isset($this->update_fields)) {
$fields = $this->update_fields;
}
if(isset($fields)) {//都是filed()方法中指定的字段
if(is_string($fields)) {
$fields = explode(",",$fields);
}
foreach ($data as $key=>$val){
if(!in_array($key,$fields)) {
unset($data[$key]);
}
}
}
// 數據自動驗證
if(!$this->autoValidation($data,$type)) return false;
// 表單令牌驗證
if(C("TOKEN_ON") && !$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);//返回$data
// 賦值當前數據對象
$this->data = $data;//將提交過來的表單數據賦值給當前的data屬性
// 返回創建的數據以供其他調用
return $data;//返回提交過來的表單數據
}
// 自動表單令牌驗證
// TODO ajax無刷新多次提交暫不能滿足
public function autoCheckToken($data) {
if(C("TOKEN_ON")){
$name = C("TOKEN_NAME");
if(!isset($data[$name]) || !isset($_SESSION[$name])) { // 令牌數據無效
return false;
}
// 令牌驗證
list($key,$value) = explode("_",$data[$name]);
if($_SESSION[$name][$key] == $value) { // 防止重復提交
unset($_SESSION[$name][$key]); // 驗證完成銷毀session
return true;
}
// 開啟TOKEN重置
if(C("TOKEN_RESET")) unset($_SESSION[$name][$key]);
return false;
}
return true;
}
/**
* 使用正則驗證數據
* @access public
* @param string $value 要驗證的數據
* @param string $rule 驗證規則
* @return boolean
*/
public function regex($value,$rule) {
$validate = array(
"require" => "/.+/",
"email" => "/^w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$/",
"url" => "/^http(s?)://(?:[A-za-z0-9-]+.)+[A-za-z]{2,4}(?:[/?#][/=?%-&~`@[]":+!#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(!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) {
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 "string":
default: // 默認作為字符串填充
$data[$auto[0]] = $auto[1];
}
if(false === $data[$auto[0]] ) unset($data[$auto[0]]);
}
}
}
return $data;//返回$data
}
/**
* 自動表單驗證
* @access protected
* @param array $data 創建數據
* @param string $type 創建類型
* @return boolean
*/
protected function autoValidation($data,$type) {
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 || $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(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]];
}
if(!empty($data[$this->getPk()])) { // 完善編輯的時候驗證唯一
$map[$this->getPk()] = array("neq",$data[$this->getPk()]);
}
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"){
switch(strtolower(trim($type))) {
case "in": // 驗證是否在某個指定范圍之內 逗號分隔字符串或者數組
$range = is_array($rule)?$rule:explode(",",$rule);
return in_array($value ,$range);
case "between": // 驗證是否在某個范圍
if (is_array($rule)){
$min = $rule[0];
$max = $rule[1];
}else{
list($min,$max) = explode(",",$rule);
}
return $value>=$min && $value<=$max;
case "equal": // 驗證是否等于某個值
return $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 $_SERVER["REQUEST_TIME"] >= $start && $_SERVER["REQUEST_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);
}
}
/**
* 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預處理
$sql = vsprintf($sql,$parse);
}else{
if(strpos($sql,"__TABLE__"))
$sql = str_replace("__TABLE__",$this->getTableName(),$sql);
}
$this->db->setModel($this->name);
return $sql;
}
/**
* 切換當前的數據庫連接
* @access public
* @param integer $linkNum 連接序號
* @param mixed $config 數據庫連接信息
* @param array $params 模型參數
* @return Model
*/
public function db($linkNum="",$config="",$params=array()){
if(""===$linkNum && $this->db) {//如果當前數據庫操作對象存在，則直接返回當前數據庫操作對象
return $this->db;//當前數據庫操作對象
}
static $_linkNum = array();//連接序號
static $_db = array();
//默認執行if
if(!isset($_db[$linkNum]) || (isset($_db[$linkNum]) && $config && $_linkNum[$linkNum]!=$config) ) {
// 創建一個新的實例，默認不執行
if(!empty($config) && is_string($config) && false === strpos($config,"/")) { // 支持讀取配置參數
//默認不執行
$config = C($config);
}
//默認執行，返回一個數據庫驅動類Db,class.php實例化對象
/**
* Db::getInstance($config);詳解
* 第一步：查找Db.class.php類庫的getInstance()方法
* 第二步：getInstance()方法調用common.php文件的get_instance_of(__CLASS__,"factory",$args);
* 第三步：get_instance_of(__CLASS__,"factory",$args)再次調用Db.class.php類的factory()方法
* 第四步：Db.class.php中的factory()方法,會加載數據庫驅動類文件DbMysql.class.php,并返回一個數據庫驅動類實例化對象
*/
$_db[$linkNum] = Db::getInstance($config);//返回一個數據庫驅動類DbMysql.class.php實例化對象
}elseif(NULL === $config){
$_db[$linkNum]->close(); // 關閉數據庫連接
unset($_db[$linkNum]);
return ;
}
if(!empty($params)) {//默認不執行
if(is_string($params)) parse_str($params,$params);
foreach ($params as $name=>$value){
$this->setProperty($name,$value);
}
}
// 記錄連接信息
$_linkNum[$linkNum] = $config;
// 切換數據庫連接
$this->db = $_db[$linkNum];//數據庫驅動類Db,class.php實例化對象
$this->_after_db();
// 字段檢測 是否自動檢測數據表字段信息
if(!empty($this->name) && $this->autoCheckFields) $this->_checkTableInfo();
return $this;//返回當前對象,其中就包括數據庫連接對象
}
// 數據庫切換后回調方法
protected function _after_db() {}
/**
* 得到當前的數據對象名稱
* @access public
* @return string
*/
public function getModelName() {
if(empty($this->name))
$this->name = substr(get_class($this),0,-5);
return $this->name;
}
/**
* 得到完整的數據表名
* @access public
* @return string
*/
public function getTableName() {
if(empty($this->trueTableName)) {
$tableName = !empty($this->tablePrefix) ? $this->tablePrefix : "";//think_
if(!empty($this->tableName)) {//默認不執行
$tableName .= $this->tableName;
}else{
//parse_name()函數將模型名轉化為小寫，如，User轉換為user
//think_user
$tableName .= parse_name($this->name);
}
//真實表名
$this->trueTableName = strtolower($tableName);
}
//think_user
return (!empty($this->dbName)?$this->dbName.".":"").$this->trueTableName;
}
/**
* 啟動事務
* @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 isset($this->fields["_pk"])?$this->fields["_pk"]:$this->pk;
}
/**
* 獲取數據表字段信息
* @access public
* @return array
*/
public function getDbFields(){
if(isset($this->options["table"])) {// 動態指定表名
$fields = $this->db->getFields($this->options["table"]);
return $fields?array_keys($fields):false;
}
if($this->fields) {
$fields = $this->fields;
unset($fields["_autoinc"],$fields["_pk"],$fields["_type"],$fields["_version"]);
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)){
throw_exception(L("_DATA_TYPE_INVALID_"));
}
$this->data = $data;
return $this;
}
/**
* 查詢SQL組裝 join
* @access public
* @param mixed $join
* @return Model
*/
public function join($join) {
if(is_array($join)) {
$this->options["join"] = $join;
}elseif(!empty($join)) {
$this->options["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) ) {
$options = $union;
}elseif(is_array($union)){
if(isset($union[0])) {
$this->options["union"] = array_merge($this->options["union"],$union);
return $this;
}else{
$options = $union;
}
}else{
throw_exception(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=""){
$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?$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
*/
public function scope($scope="",$args=NULL){
if("" === $scope) {
if(isset($this->_scope["default"])) {
// 默認的命名范圍
$options = $this->_scope["default"];
}else{
return $this;
}
}elseif(is_string($scope)){ // 支持多個命名范圍調用 用逗號分割
$scopes = explode(",",$scope);
$options = array();
foreach ($scopes as $name){
if(!isset($this->_scope[$name])) continue;
$options = array_merge($options,$this->_scope[$name]);
}
if(!empty($args) && is_array($args)) {
$options = array_merge($options,$args);
}
}elseif(is_array($scope)){ // 直接傳入命名范圍定義
$options = $scope;
}
if(is_array($options) && !empty($options)){
$this->options = array_merge($this->options,array_change_key_case($options));
}
return $this;
}
/**
* 指定查詢條件 支持安全過濾
* @access public
* @param mixed $where 條件表達式
* @param mixed $parse 預處理參數
* @return Model
*/
public function where($where,$parse=null){
if(!is_null($parse) && is_string($where)) {
if(!is_array($parse)) {
$parse = func_get_args();
array_shift($parse);
}
$parse = array_map(array($this->db,"escapeString"),$parse);
$where = vsprintf($where,$parse);
}elseif(is_object($where)){
$where = get_object_vars($where);
}
$this->options["where"] = $where;
return $this;
}
/**
* 指定查詢數量
* @access public
* @param mixed $offset 起始位置
* @param mixed $length 查詢數量
* @return Model
*/
public function limit($offset,$length=null){
$this->options["limit"] = is_null($length)?$offset:$offset.",".$length;
return $this;
}
/**
* 指定分頁
* @access public
* @param mixed $page 頁數
* @param mixed $listRows 每頁數量
* @return Model
*/
public function page($page,$listRows=null){
$this->options["page"] = is_null($listRows)?$page:$page.",".$listRows;
return $this;
}
/**
* 設置模型的屬性值
* @access public
* @param string $name 名稱
* @param mixed $value 值
* @return Model
*/
public function setProperty($name,$value) {
if(property_exists($this,$name))
$this->$name = $value;
return $this;
}
}?>
