List of ThinkPHP's CURD methods and query methods_PHP tutorial

The so-called CURD. That is, the four basic operations (CURD) of database operations: C:create (create), U:update (update), R:read (read) and D:detele (delete).
In ThinkPHP, methods do not necessarily have these names. Here are the common methods: select, find, findAll, save, create, etc.:

D read:
select->() queries the data set, which is the same as findAll->(). For example:
$User->where(‘status=1′)->order(‘create_time’)->limit(10)->select();
Note: Except for the select method, which must be placed last in a coherent operation, the order of calling methods of other consecutive operations is not sequential. For example, the following code is equivalent to the above:
$User->order(‘create_time’)->where(‘status=1′)->limit(10)->select();

If you are not used to using continuous operations, the new version also supports the method of directly using parameters to perform queries. For example, the above code can be changed to
Written as:
$User->select(array('order'=>'create_time', 'where'=>'status=1', 'limit'=>'10'));

The find->() method is similar to the above two methods. The difference is that only one piece of data is returned. Can be used together with getField->() to obtain a field value of a record.

Select has the same effect as findall and returns a two-dimensional array. Such as
array(1) {
[0] => array(8)
{ ["rank_id"] => string(3) “151″
["rank_name"] => string(7) "Test 9"
["rank_memo"] => string(3) “123″
["uid"] => string(5) “59471″
["rank_kw"] => string(6) "Important"
["rank_uptime"] => string(10) “1280202914″
["isverify"] => string(1) “0″
["ishot"] => string(1) “0″
}
}
The effect of find is as follows, returning a one-dimensional array:
array(8) {
["rank_id"] => string(3) “151″
["rank_name"] => string(7) "Test 9"
["rank_memo"] => string(3) “123″
["uid"] => string(5) “59471″
["rank_kw"] => string(6) "Important"
["rank_uptime"] => string(10) “
1280202914″ ["isverify"] => string(1) “0″
["ishot"] => string(1) “0″
}

Where method: used to query or update the definition of conditions

Table method: Define the name of the data table to be operated
$Model->Table(‘think_user user’)->where(‘status>1′)->select();

field method: define the field to be queried
The parameters of the field method support strings and arrays, for example,
$Model->field(‘id,nickname as name’)->select();
$Model->field(array(‘id’,’nickname’=>’name’))->select();
If you do not use the field method to specify a field, the default is equivalent to using field(‘*’).

U updated, C created:

data, add, save methods: assign, add, and save data objects. For example:
$data['name'] = 'ThinkPHP';
$data['email'] = ‘ThinkPHP@gmail.com’;
$Model->data($data)->add();//Newly added, equivalent to insert, coherent writing
$Model->add($data); //New, equivalent to insert, non-coherent writing
$Model->data($data)->where(‘id=3′)->save(); //Modify, equivalent to update

It should be noted that in the save method, if the data has not changed, the default return operation is FALSE. But this save execution is OK, this needs attention.

create->() automatically forms data in the form of $data from the POST fields

$User=D("User");
$User->create(); //Create by default using data submitted by the form
$User->add(); //Add

If your primary key is of the auto-increasing type, and if the data is successfully inserted, the return value of the Add method is the latest entered primary key value, which can be obtained directly.

Data objects created using the data method will not be automatically verified and filtered, please handle it yourself. But those who are practicing add command
During the save operation, fields that do not exist in the data table and illegal data types (such as objects, arrays and other non-scalar data) will automatically
With automatic filtering, you don't have to worry about SQL errors caused by writing to non-data table fields.

The command verification, automatic verification and automatic completion (we will look at the related usage later) functions that we are familiar with are actually
Must pass the create method to take effect. The data object created by the Create method is stored in memory and is not actually written to the database
, just use the add or save method. If you just want to simply create a data object, there is no need to complete some additional functions
If so, you can use the data method to simply create a data object.

setInc and setDec methods. For updates to statistical fields (usually numeric types):
$Model->setInc(‘score’,’id=5′,3); // Add 3 to the user’s points
$Model->setInc(‘score’,’id=5′); // Add 1 to the user’s points
$Model->setDec(‘score’,’id=5′,5); // The user’s points are reduced by 5
$Model->setDec(‘score’,’id=5′); // The user’s points are reduced by 1

D Delete:

delete->() delete data
$User->where(‘status=0′)->order(‘create_time’)->limit(’5′)->delete();

Other common methods of Model:

order method: result sorting Example:
order(‘id desc’)
The sorting method supports sorting multiple fields
order(‘status desc,id asc’)
The parameters of the order method support strings and arrays. The usage of arrays is as follows:
order(array(‘status’=>’desc’,’id’))

limit method: result limit
limit(’1,10′)
If using limit(’10′) it is equivalent to limit(’0,10′)

Page method: Query paging. The usage of the Page method is similar to the limit method. The format is:
Page(‘page[,listRows]‘)
Page represents the current page number, and listRows represents the number of records displayed on each page. For example, if 10 records are displayed on each page, get the data on page 2:
Page(’2,10′)
If listRow is not written, the value of limit(‘length’) will be read. For example, if 25 records are displayed on each page, the data on page 3 will be obtained:
limit(25)->page(3);
If limit is not set, the default is to display 20 records per page.

Join method: Query Join support. The parameters of the Join method support strings and arrays, and the join method is the only method that can be called multiple times in a coherent operation. For example:
$Model->join(‘ work ON artist.id = work.artist_id’)->join(‘card ON artist.card_id = card.id’)->select();
The LEFT JOIN method is used by default. If you need to use other JOIN methods, you can change it to
$Model->join(‘RIGHT JOIN work ON artist.id = work.artist_id’)->select();

Distinct method: Query Disiinct support. Perform unique filtering when querying data
$Model->Distinct(true)->select();

Relation method: related query support
$Model->Relation(true)->select();

Conditional query

$map->put('name','php'); //name='php'

('name',array('like','think')); //name like '...'

('id',array('in',array(1,2,4)));

('id',array('10','3','or')); //id>=10 or <=3

thinkphp multi-table query statement

1. table() function
thinkphp provides a table() function. For specific usage, please refer to the following statement:
$list=$Demo->table('think_blog blog,think_type type')->where('blog.typeid=type.id')->field('blog.id as id,blog.title,blog .content,type.typename as type')->order('blog.id desc' )->limit(5)->select();
echo $Demo->getLastSql(); //Print the SQL statement and check it

2. join() function
Take a look at the code:
$Demo = M('artist');
$Demo->join('RIGHT JOIN think_work ON think_artist.id = think_work.artist_id' );
//You can use INNER JOIN or LEFT JOIN. Be sure to pay attention to the prefix of the table name here!
echo $Demo->getLastSql(); //Print the SQL statement and check it

Attached is the simplest code for adding, deleting and checking
[php]
// Query data
public function index(){
$Form = M("Form");
$list = $Form->limit(5)->order('id desc')->findAll();
$this->assign('list',$list);
$this->display();
}
//Write data
public function insert() {
$Form = D("Form");
If($vo = $Form->create()) {
$list=$Form->add();
If($list!==false){
                 $this->success('Data saved successfully!');
         }else{
                 $this->error('Data writing error!');
         } 
}else{
           $this->error($Form->getError());
}  
}

//Update data
public function update() {
$Form = D("Form");
If($vo = $Form->create()) {
$list=$Form->save();
If($list!==false){
                 $this->success('Data updated successfully!');
         }else{
                 $this->error("No data updated!");
         } 
}else{
           $this->error($Form->getError());
}  
}
// Delete data
public function delete() {
If(!emptyempty($_POST['id'])) {
$ Form = m ("form");
$ Result = $ form-& gt; delete ($ _ post ['id']);
If(false !== $result) {
                 $this->ajaxReturn($_POST['id'],'Delete successfully!',1);
         }else{
                $this->error('Deletion error!');
         } 
}else{
​​​​ $this->error('The deleted item does not exist!');
}  
}

http://www.bkjia.com/PHPjc/477994.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/477994.htmlTechArticleThe so-called CURD. That is, the four basic operations (CURD) of database operations: C:create (create), U:update (update), R:read (read) and D:detele (delete). In ThinkPHP, these are not necessarily...