ThinkPHP framework SQL operation chain writing principle (easy to understand)

The following tutorial column of thinkphp framework will introduce to you the principle of SQL operation chain writing method of ThinkPHP framework. I hope it will be helpful to friends in need!

Introduction

If you have had several interviews, it is not difficult to find out that although domestic TPs have always been criticized. But this does not affect its popularity in the development of the majority of enterprises. It has a strong community and a practical and detailed Chinese manual. One thing I believe everyone is familiar with is his chain writing method. The chain writing method simplifies the SQL workload to a certain extent. OK, how is it implemented? Let's start with object-oriented and analyze the implementation principle of chain writing.

The following statement

$User->limit(10)->where('status=1')->select();

Code

We know that the object-oriented method can return a variety of data types, of course, it can also returnObject itself, so we can use this feature to achieve

<?php
class Test{    
private $var = "";    
public function Func(){        
$this->var = "Var is change";        
return $this;
    }

}

    $obj = new Test();
    var_dump($obj);
    var_dump($obj->Func());

The printed result:

object(Test)[1]  
private 'var' => string '' (length=0)
object(Test)[1]  
private 'var' => string 'Var is change' (length=13)

It is not difficult to find: our private variables occur changed to to . YeahJustissay,we ##obj->Func(), after execution, returns an object with $var = "Var is change".

$User->limit(10)->where('status=1')->select();

Then this statement is not difficult to understand. After the method is executed, the object is passed to the next method, and so on.

Simple Select() implementation

<?php    
class UserModel{        
private $field     ="*"; 
        private $tableName ="";        
        private $where     ="";        
        private $order     ="";        
        private $limit     ="";        
        function field($field){            
        $this->field = $field;            
        return $this;
        }        
        function table($tableName){            
        $this->table = $tableName;            
        return $this;
        }        
        function order($order){            
        $this->order = "ORDER BY ".$order;            
        return $this;
        }        
        function where($where){            
        $this->where = "WHERE ".$where;            
        return $this;
        }        
        function limit($index, $limit = 0){            
        $this->limit = "LIMIT ".$index;            
        if($limit){                
        $this->limit.= ",{$limit}";
            }            
            return $this;
        }        
        function select(){            
        if(empty($this->tableName)){                
        $this->tableName = str_replace("Model", "", __CLASS__);//如果表名不指定，则获取类名
            }
            $selectSql ="SELECT {$this->field} 
                         FROM `{$this->tableName}` 
                         {$this->where} 
                         {$this->order} 
                         {$this->limit}"; 
                         //构造SQL语句模版串            
                         echo $selectSql;            
                         //return mysql_query($selectSql);  执行拼接后的SQL语句
        }

    }

    $user = new UserModel();
    $user->where("`user` = 1")->order("`user` DESC")->limit(5)->select();?>

Summary

The idea is probably to assign values ​​to each condition of the SQL statement through the chain operation method, and then In the final step, SQL statements are processed uniformly. This is just a simple implementation of the principle. Interested students can judge multiple types of method parameters and assign conditions more flexibly. For example, the where method can pass an array. Then you can also follow this idea and do things like INSERT()

,

UPDATE(), DELETE(), etc. This is just an introduction. If you want to learn more about chain writing, you can also look at the TP source code.

The above is the detailed content of ThinkPHP framework SQL operation chain writing principle (easy to understand). For more information, please follow other related articles on the PHP Chinese website!