A brief analysis of the principle of SQL operation chain writing in various frameworks such as ThinkPHP

Chain operation seems mysterious to many people. In fact, after reading this article, you will gradually understand chain operation. We go deep into the core of ThinkPHP, and we study the chain operations of ThinkPHP and other frameworks. As long as you know one thing, you will know everything else.

ThinkPHP has a very 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 return The object 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 variable $var has changed. In other words, our $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}"
                         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 process the SQL in a unified manner in the last step statement. 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.

Related recommendations:

A package class for the database that I modified based on DB.php at the bottom of ThinkPHP

Based on The DB.php at the bottom of ThinkPHP has been modified by me to encapsulate the database. Because I don’t know how to learn the ThinkPHP framework, I went to see its database operations myself...

thinkPHP WeChat Sharing Interface JSSDK Example Explanation

This article mainly introduces the usage of thinkPHP WeChat sharing interface JSSDK, and analyzes thinkPHP adjustment in the form of examples...

The above is the detailed content of A brief analysis of the principle of SQL operation chain writing in various frameworks such as ThinkPHP. For more information, please follow other related articles on the PHP Chinese website!