ThinkPHP5.1学习笔记数据库操做

时间 2020-02-17

标签 thinkphp5.1 thinkphp 学习笔记数据库栏目 PHP 繁體版

原文原文链接

数据库

参见《Thinkphp5.1彻底开发手册》学习
Mirror王宇阳php

数据库链接

ThinkPHP采用内置抽象层对数据库操做进行封装处理；且基于PDO模式，能够适配各类数据库。mysql

数据库链接的配置文件(config/database.php)设置数据库的链接信息sql

class DataTest extends Controller// 数据库链接
{ // url => http://localhost/tp5.1/public/index.php/index/data_test
    public function index()
    {
        $data = Db::table('tp_access')->select();
        $data = Db::name('access')->select();
        return json($data);

    }
}

查询控制器(数据库操做)

想要查看SQL的执行语句细节能够配置：config/app.php -> app_trace => true;thinkphp

开启后就能够在HTML页面右下角打开SQL语句的具体执行过程数据库

注意：json输出的数据没法使用这一功能哦！json

查询数据

查询单个数据使用find方法：数组

// table方法必须指定完整的数据表名
Db::table('think_user')->where('id',1)->find();

最终生成的SQL语句多是：缓存

SELECT * FROM `think_user` WHERE  `id` = 1 LIMIT 1

find 方法查询结果不存在，返回 null，不然返回结果数组安全

V5.1.23+版本开始，支持findOrEmpty方法，当查询不存在的时候返回空数组而不是Null。服务器

// table方法必须指定完整的数据表名
Db::table('think_user')->where('id',1)->findOrEmpty();

若是没有查找到数据，则会抛出一个think\db\exception\DataNotFoundException异常。

try{ //捕获异常
    // table方法必须指定完整的数据表名
    $data = Db::table('think_user')->where('id',1)->findOrEmpty();
} catch (DataNotFoundException $err) {
    return '数据查询发送异常！'
}

查询多个数据（数据集）使用select方法：

Db::table('think_user')->where('status',1)->select();

最终生成的SQL语句多是：

SELECT * FROM `think_user` WHERE `status` = 1

select 方法查询结果是一个二维数组，若是结果不存在，返回空数组

若是但愿在没有查找到数据后抛出异常可使用

try{ //捕获异常
    $data = Db::table('think_user')->where('status',1)->selectOrFail();
} catch (DataNotFoundException $err) {
    return '数据查询发送异常！'
}

默认状况下，find和select方法返回的都是数组，区别在于后者是二维数组。

系统提供了一个db助手函数，能够更方便的查询：

db('user')->where('id',1)->find();
db('user')->where('status',1)->select();

db方法的第一个参数的做用和name方法同样，若是须要使用不一样的数据库链接，可使用：

db('user','db_config1')->where('id', 1)->find();

查询某个字段的值能够用 value(‘字段名’)

// 返回某个字段的值
Db::table('think_user')->where('id',1)->value('name');

value 方法查询结果不存在，返回 null

查询某一列的值能够用 colum('字段名/列名')

// 返回数组
Db::table('think_user')->where('status',1)->column('name');
// 指定id字段的值做为索引
Db::table('think_user')->where('status',1)->column('name','id');

若是要返回完整数据，而且添加一个索引值的话，可使用

// 指定id字段的值做为索引 返回全部数据
Db::table('think_user')->where('status',1)->column('*','id');

column 方法查询结果不存在，返回空数组

数据分批处理可使用 chunk

咱们能够所有用户表数据进行分批处理，每次处理 100 个用户记录：

Db::table('think_user')->chunk(100, function($users) {
    foreach ($users as $user) {
        //
    }
});
// 或者交给回调方法myUserIterator处理
Db::table('think_user')->chunk(100, 'myUserIterator');

你能够经过从闭包函数中返回false来停止对后续数据集的处理：

Db::table('think_user')->chunk(100, function($users) {
    foreach ($users as $user) {
        // 处理结果集...
        if($user->status==0){
            return false;
        }
    }
});

也支持在chunk方法以前调用其它的查询方法，例如：

Db::table('think_user')
->where('score','>',80)
->chunk(100, function($users) {
    foreach ($users as $user) {
        //
    }
});

chunk方法的处理默认是根据主键查询，支持指定字段，例如：

Db::table('think_user')->chunk(100, function($users) {
    // 处理结果集...
    return false;
},'create_time');

而且支持指定处理数据的顺序。

Db::table('think_user')->chunk(100, function($users) {
    // 处理结果集...
    return false;
},'create_time', 'desc');

chunk方法通常用于命令行操做批处理数据库的数据，不适合WEB访问处理大量数据，很容易致使超时。

大批量数据处理

若是你须要处理大量的数据，可使用新版提供的游标查询功能，该查询方式利用了PHP的生成器特性，能够大幅减小大量数据查询的内存占用问题。

$cursor = Db::table('user')->where('status', 1)->cursor();
foreach($cursor as $user){
    echo $user['name'];
}

cursor方法返回的是一个生成器对象，user变量是数据表的一条数据（数组）。

JSON类型数据查询（mysql）

// 查询JSON类型字段 （info字段为json类型）
Db::table('think_user')
    ->where('info->email','thinkphp@qq.com')
    ->find();

链式查询简单认识

查询规则
- 经过指向符号 -> 屡次连续的调用方法
```
Db::table('think_user')
    ->where('status',1)
    ->order('create_time')
    ->limit(10)
    ->select();
```
- 屡次i的调用使用返回的都是数据库对象，能够屡次的链式查询数据对象的方法
- 最后的数据库对象可使用 find()、select() 等结果方法，返回数据结果
- find()、select()、value()、column() 是结果查询方法，并非链式查询方法

链式查询方法：

系统支持的链式操做方法包含：

连贯操做	做用	支持的参数类型
where*	用于AND查询	字符串、数组和对象
whereOr*	用于OR查询	字符串、数组和对象
wheretime*	用于时间日期的快捷查询	字符串
table	用于定义要操做的数据表名称	字符串和数组
alias	用于给当前数据表定义别名	字符串
field*	用于定义要查询的字段（支持字段排除）	字符串和数组
order*	用于对结果排序	字符串和数组
limit	用于限制查询结果数量	字符串和数字
page	用于查询分页（内部会转换成limit）	字符串和数字
group	用于对查询的group支持	字符串
having	用于对查询的having支持	字符串
join*	用于对查询的join支持	字符串和数组
union*	用于对查询的union支持	字符串、数组和对象
view*	用于视图查询	字符串、数组
distinct	用于查询的distinct支持	布尔值
lock	用于数据库的锁机制	布尔值
cache	用于查询缓存	支持多个参数
relation*	用于关联查询	字符串
with*	用于关联预载入	字符串、数组
bind*	用于数据绑定操做	数组或多个参数
comment	用于SQL注释	字符串
force	用于数据集的强制索引	字符串
master	用于设置主服务器读取数据	布尔值
strict	用于设置是否严格检测字段名是否存在	布尔值
sequence	用于设置Pgsql的自增序列名	字符串
failException	用于设置没有查询到数据是否抛出异常	布尔值
partition	用于设置分表信息	数组字符串

全部的连贯操做都返回当前的模型实例对象（this），其中带*标识的表示支持屡次调用。

更多查询

屡次查询并不须要每次都建立一个实例；能够保存实例对象进行反复调用：

$user = Db::name('user');
$data = $user->select();

public function getModelData()
    {
        $book = Db::table('tp_book');     // 建立tp_book的实例并保持$book
        $data = $book->select();
        return json($data);
        $data1 = $book->where('id',1)->column('title');
        //使用被保持的实例
        return json($data1); // 结果返回 莎士比亚
        $data2 = $book->column('title');
        // 被保存的实例会保留上一个查询结果(对象)
        return json($data3); // 结果返回 与 $data2 一致
    }

实例会保存上一个查询对象结果，但使用removerOption()方法能够清理上一个保留的值

$data3 = $book->removeOption('where')->column('title');
return json($data3); // 结果返回 没有where条件限制了

增删改操做

新增数据

ThinkPHP5.1使用insert()、insertGetId()方法向数据表添加一条数据

使用 Db 类的 insert 方法向数据库提交数据

$data = ['foo' => 'bar', 'bar' => 'foo'];
// 笔者在insert()的时候，发现中文内容添加后会在数据库中显示空白
Db::name('user')->insert($data);

insert 方法添加数据成功返回添加成功的条数，一般状况返回 1

// 新增数据到数据表中
    public function insert()
    {
        $book = Db::table('tp_book');
        // 匹配添加数据
        $data = [ // 可为空Null的、自动增补的能够忽略不添加
            'user_id'    =>  '66',
            'title'      =>  'Mirror'
        ];

        $book->insert($data);

        $select = $book->select();
        return json($select);
    }

或者使用data方法配合insert使用。

$data = ['foo' => 'bar', 'bar' => 'foo'];
Db::name('user')
    ->data($data)
    ->insert();

若是你的数据表里面没有foo或者bar字段，那么就会抛出异常。

若是不但愿抛出异常，可使用下面的方法：

$data = ['foo' => 'bar', 'bar' => 'foo'];
Db::name('user')->strict(false)->insert($data);

不存在的字段的值将会直接抛弃。

若是是mysql数据库，支持replace写入，例如：

$data = ['foo' => 'bar', 'bar' => 'foo'];
Db::name('user')->insert($data, true);

添加数据后若是须要返回新增数据的自增主键，可使用insertGetId方法新增数据并返回主键值：

$userId = Db::name('user')->insertGetId($data);

insertGetId 方法添加数据成功返回添加数据的自增主键

添加多条数据直接向 Db 类的 insertAll 方法传入须要添加的数据便可

public  function insertAll()//批量添加到数据表
    {
        $dataAll = [
            [
                'user_id'    =>  '66',
                'title'      =>  '《白帽子讲Web安全》'
            ],
            [
                'user_id'   => '88',
                'title'     => '《乔布斯传》'
            ],
            [
                'user_id'   => '99',
                'title'     => '《白夜行》'
            ],
        ];


        $kk = Db::table('tp_book')->insertAll($dataAll);
        return $kk;
    }

insertAll 方法添加数据成功返回添加成功的条数

若是批量插入的数据比较多，能够指定分批插入，使用limit方法指定每次插入的数量限制。

$data = [
    ['foo' => 'bar', 'bar' => 'foo'],
    ['foo' => 'bar1', 'bar' => 'foo1'],
    ['foo' => 'bar2', 'bar' => 'foo2']
    ...
];
// 分批写入 每次最多100条数据
Db::name('user')->data($data)->limit(100)->insertAll();

修改数据

// 修改数据
    public function update()
    {
        $date = [
            'title'     =>  '《解忧杂货铺》'
        ];

        $kk = Db::table('tp_book')->where('user_id','99')->update($date);
        return $kk;
    }

update 方法返回影响数据的条数，没修改任何数据返回 0

若是数据中包含主键，能够直接使用：

Db::name('user')
    ->update(['name' => 'thinkphp','id'=>1]);

若是要更新的数据须要使用SQL函数或者其它字段，可使用下面的方式：

Db::name('user')
    ->where('id',1)
    ->inc('read_time') //对字段增值
    ->dec('score',3) //对字段减值
    ->exp('name','UPPER(name)') // 在字段中使用mysql函数
    ->update();

可使用setInc/setDec方法自增或自减一个字段的值（如不加第二个参数，默认步长为1）。

// score 字段加 1
Db::table('think_user')
    ->where('id', 1)
    ->setInc('score');
// score 字段加 5
Db::table('think_user')
    ->where('id', 1)
    ->setInc('score', 5);
// score 字段减 1
Db::table('think_user')
    ->where('id', 1)
    ->setDec('score');
// score 字段减 5
Db::table('think_user')
    ->where('id', 1)
    ->setDec('score', 5);

setInc/setDec支持延时更新，若是须要延时更新则传入第三个参数，下例中延时10秒更新。

Db::name('user')->where('id', 1)->setInc('score', 1, 10);

V5.1.7+版本之后，支持使用raw方法进行数据更新，适合在数组更新的状况。

Db::name('user')
    ->where('id', 1)
    ->update([
        'name'      =>  Db::raw('UPPER(name)'),
        'score'     =>  Db::raw('score-3'),
        'read_time' =>  Db::raw('read_time+1')
    ]);

字段值更新 setField('原字段名','新字段名')

Db::name('user')
    ->where('id',1)
    ->setField('name', 'thinkphp');

删除数据

// 根据主键删除
Db::table('think_user')->delete(1);
Db::table('think_user')->delete([1,2,3]);

// 条件删除    
Db::table('think_user')->where('id',1)->delete();
Db::table('think_user')->where('id','<',10)->delete();

// 无条件删除全部数据
Db::name('user')->delete(true);

查询表达式

比较查询

Db::name('book')->where('id',80)->find();       //简写
Db::name('book')->where('id','=',80)->find();   //完整；且与第一条赞成义

5.1还支持新的查询方法

whereField('表达式','查询条件');
whereOrField('表达式','查询条件');

Field使用字段的驼峰命名方式。

where() 格式

where( 字段名 , 表达式 , 查询条件);

表达式包含如下：

表达式	含义	快捷查询方法
=	等于
<>	不等于
>	大于
>=	大于等于
<	小于
<=	小于等于
[NOT] LIKE	模糊查询	`whereLike/whereNotLike`
[NOT] BETWEEN	（不在）区间查询	`whereBetween/whereNotBetween`
[NOT] IN	（不在）IN 查询	`whereIn/whereNotIn`
[NOT] NULL	查询字段是否（不）是NULL	`whereNull/whereNotNull`
[NOT] EXISTS	EXISTS查询	`whereExists/whereNotExists`
[NOT] REGEXP	正则（不）匹配查询（仅支持Mysql）
[NOT] BETWEEM TIME	时间区间比较	whereBetweenTime
> TIME	大于某个时间	`whereTime`
< TIME	小于某个时间	`whereTime`
>= TIME	大于等于某个时间	`whereTime`
<= TIME	小于等于某个时间	`whereTime`
EXP	表达式查询，支持SQL语法	`whereExp`

区间查询(建议使用快捷)

link 表达式进行模糊查询

$data = Db::table('tp_book')->where('title','like','%白%')->column('title');
return json($data);

支持使用数组

// 查询 title中包含 白和M开头的书籍
$data = Db::table('tp_book')
    ->where('title','like',['%白%','M%'],'OR')
    ->column('title');
return json($data);

为了更加方便，应该直接使用whereLike方法

Db::name('user')->whereLike('name','thinkphp%')->select();
Db::name('user')->whereNotLike('name','thinkphp%')->select();

between 指定区间范围查找

查询条件支持字符串或者数组，例如：

Db::name('user')->where('id','between','1,8')->select();

和下面的等效：

Db::name('user')->where('id','between',[1,8])->select();

最快捷的查询方法是：

Db::name('user')->whereBetween('id','1,8')->select();
Db::name('user')->whereNotBetween('id','1,8')->select();

in 指定索引查找

// in、not in 指定全部查找
$data = Db::table('tp_book')->where('id','in','1,2,23')->column('title');
$data = Db::table('tp_book')->where('id','in','[1,2,23]')->column('title');

$data = Db::table('tp_book')->whereIn('id','1,2,34')->column('title');
$data = Db::table('tp_book')->whereNotIn('id','1,2,3,4,44')->column('title');
return json($data);

Null 查询字段是否（不）是Null

// null、not null 查询指定字段是否能够为Null/Not Null
$data = Db::table('tp_access')->where('details','null')->column('user_id');
$data = Db::table('tp_access')->where('details','notnull')->column('user_id');
$data = Db::table('tp_access')->whereNull('details')->column('user_id');
$data = Db::table('tp_access')->whereNotNull('details')->column('user_id');
return json($data);

EXP:其它查询

支持更复杂的查询状况例如：

Db::name('user')->where('id','in','1,3,8')->select();

能够改为：

Db::name('user')->where('id','exp',' IN (1,3,8) ')->select();

exp查询的条件不会被当成字符串，因此后面的查询条件可使用任何SQL支持的语法，包括使用函数和字段名称。

$data = Db::table('tp_access')->where('id','exp','in (1,2,3,4)')->column('user_id');// 快捷 ↓
$data = Db::table('tp_access')->whereExp('id','in (1,2,3,4)')->column('user_id');
// 等效于 ==> SELECT `user_id` FROM `tp_access` WHERE ( `id` in (1,2,3,4) )

$data = Db::table('tp_book')->whereExp('id','>=20 and user_id =88 ')->column('title');
$data = Db::table('tp_book')->whereExp('','id >=20 and user_id =88 ')->column('title');
// 等效于 ==> SELECT `title` FROM `tp_book` WHERE ( `id` >=20 and user_id =88 )
print_r($data);

时间查询

传统查询 where()

where方法支持时间比较，例如：

// 采用比较符号比较时间
$data = Db::table('tp_one')->where('create_time','< time','2016-10-10 00:00:00')->select();
// ==> SELECT * FROM `tp_one` WHERE `create_time` < '2016-10-10 00:00:00'
// 在第二参数明确 time 的时候，第三个参数会自动按照完整的time格式填充（年-月-日 时:分:秒）

// 时间区间查询
where('create_time', 'between time', ['2015-1-1', '2016-1-1']);

第三个参数能够传入任何有效的时间表达式，会自动识别你的时间字段类型，支持的时间类型包括timestamps、datetime、date和int

区间查询 whereTime()/wherebetween()/wherebetweenTime():

// 采用whereTime()区间查询时间 (whereTime()和between time 结果是同样的，推荐后者)
$data = Db::table('tp_one')
    ->where('create_time','between time',['2018-01-01','2019-01-01'])
    ->select();
$data = Db::table('tp_one')
    ->whereTime('create_time',['2018-01-01','2019-01-01'])
    ->select();
// ==> SELECT * FROM `tp_one` WHERE `create_time` BETWEEN '2018-01-01 00:00:00' AND '2019-01-01 00:00:00'
// wherebetween() 也支持如上的区间Time查询
$data = Db::table('tp_one')
    ->whereBetween('create_time',['2018-01-01','2019-01-01'])
    ->select();
// wherebetweenTime() 也是一个支持时间起始查询函数
$data = Db::table('tp_one')
    ->whereBetweenTime('create_time','2018-01-01','2019-01-01')
    ->select();
// 若是第三个参数为空则表明查询当天（一天）

whereTime()还支持时间便捷固定查询：

关键字 (whereTime()的第三个参数值)	说明
today	今天
yesterday	昨天
week	本周
last week	上周
month	本月
last month	上月
year	本年
last year	去年

同时还支持指定的时间数据查询；例如两小时内就是：-2 hour

whereBetweenTimeField()多时间(字)段查询

V5.1.17+版本开始，能够支持对两个时间字段的区间比较

// 查询有效期内的活动
Db::name('event')
  ->whereBetweenTimeField('start_time','end_time')
    ->select();

上面的查询至关于

// 查询有效期内的活动
Db::name('event')
  ->whereTime('start_time', '<=', time())
    ->whereTime('end_time', '>=', time())
    ->select();

聚合查询

在应用中咱们常常会用到一些统计数据，例如当前全部（或者知足某些条件）的用户数、全部用户的最大积分、用户的平均成绩等等，ThinkPHP为这些统计操做提供了一系列的内置方法，包括：

方法	说明
count	统计数量，参数是要统计的字段名（可选）
max	获取最大值，参数是要统计的字段名（必须）
min	获取最小值，参数是要统计的字段名（必须）
avg	获取平均值，参数是要统计的字段名（必须）
sum	获取总分，参数是要统计的字段名（必须）

聚合方法若是没有数据，默认都是0，聚合查询均可以配合其它查询条件

V5.1.5+版本开始，聚合查询能够支持JSON字段类型(MySQL5.7+开始支持JSON)

count()统计数量: 能够根据表的行数或根据字段的行数

$data = Db::table('tp_book')->count();
// ==> SELECT COUNT(*) AS tp_count FROM `tp_book`
$data = Db::table('tp_book')->count('id');
// ==> SELECT COUNT(`id`) AS tp_count FROM `tp_book`

max()/min()获取最值:能够根据字段名获取字段列中最值；若是字段中的不是数值，函数会自动强制转换，能够经过定义第二参数为“false”来取消强制转换的行为

// max()/min() 最值函数
$data = Db::table('tp_book')
    ->max('user_id');
// ==> SELECT MAX(`user_id`) AS tp_max FROM `tp_book`
$data = Db::table('tp_book')
    ->max('title');
$data = Db::table('tp_book')
    ->max('title',false); // 和↑条同做用，可是这条将不强制转换，按照编码进行
// ==> SELECT MAX(`title`) AS tp_max FROM `tp_book`

avg()平均值计算

$data = Db::table('tp_book')->avg('user_id');
// ==> SELECT AVG(`user_id`) AS tp_avg FROM `tp_book`

sum()求和计算

$data = Db::table('tp_book')->sum('user_id');
// ==> SELECT SUM(`user_id`) AS tp_sum FROM `tp_book`

子查询

使用fetchSql()方法，不执行SQL语句而是返回SQL语句，默认True

$subQuery = Db::table('think_user')
    ->field('id,name')
    ->where('id', '>', 10)
    ->fetchSql(true)
    ->select();

生成的subQuery结果为：

SELECT `id`,`name` FROM `think_user` WHERE `id` > 10

使用buidSql()方法，返回SQL语句且不须要执行select()同时添加两侧括号

$subQuery = Db::table('think_user')
    ->field('id,name')
    ->where('id', '>', 10)
    ->buildSql();

生成的subQuery结果为：

( SELECT `id`,`name` FROM `think_user` WHERE `id` > 10 )

在SQL语句中咱们须要用到子查询的功能，就是利用SQL1语句的查询结果给SQL2语句使用

原生SQL语句：（具有子查询）

SELECT * FROM `tp_one` WHERE id in (SELECT uid FROM tp_two where gender = '男');

构造ThinkPHP的子查询代码：

$sql_1 = Db::table('tp_two')
    ->field('uid')
    // field()方法主要做用是标识要返回或者操做的字段，能够用于查询和写入操做。
    ->where('gender','男')
    ->buildSql();
$sql = Db::table('tp_one')
    ->whereIn('id',$sql_1)
    ->select();
// ==> SELECT * FROM `tp_one` WHERE `id` = ( SELECT `uid` FROM `tp_two` WHERE `gender` = '男' )
// 这里使用WhereIn出现的问题就是本来应该是 IN 却变成了 = 符号

$sql_exp =  Db::table('tp_one')
    ->whereExp('id','IN'.$sql_1)
    ->select();
// ==> SELECT * FROM `tp_one` WHERE ( `id` IN( SELECT `uid` FROM `tp_two` WHERE `gender` = '男' ) )
// 因为whereIn没法正确的使用，因而采用whereExp()方法构造IN并使用链接符链接$sql_1

使用闭包构造子查询

IN/NOT IN和EXISTS/NOT EXISTS之类的查询能够直接使用闭包做为子查询，例如：

Db::table('think_user')
    ->where('id', 'IN', function ($query) {
        $query->table('think_profile')->where('status', 1)->field('id');
    })
    ->select();

原生查询

query()/读操做

query方法用于执行SQL查询操做，若是数据非法或者查询错误则返回false，不然返回查询结果数据集（同select方法）。

使用示例：

Db::query("select * from think_user where status=1");

execute()/写操做

execute用于更新和写入数据的sql操做，若是数据非法或者查询错误则返回false，不然返回影响的记录数。

使用示例：

Db::execute("update think_user set name='thinkphp' where status=1");

链式查询-建议参考手册

where

表达式查询：即以前的那些普通的多个表达式组合的查询方式

例如：where比较查询、whereIn、whereLike……

关联数组查询：等值AND和IN函数条件

// Where数组关联查询能够等值AND和IN函数条件
$data = Db::table('tp_one')->where([
    'math'      =>  88,
    'chinese'   =>  88,
])->select();
// ==> SELECT * FROM `tp_one` WHERE `math` = 88 AND `chinese` = 88
$data = Db::table('tp_one')->where([
    'math'      =>  88,
    'chinese'   =>  [88,99,11],//等效于IN (88,99,11)
])->select();
// ==> SELECT * FROM `tp_one` WHERE `math` = 88 AND `chinese` IN (88,99,11)

索引数组查询：批量设置查询条件

// Where索引数组查询
$data = Db::table('tp_one')->where([
      ['math','<=','88'],
      ['chinese','>','90'],
  ])->select();
// ==>  SELECT * FROM `tp_one` WHERE `math` <= 88 AND `chinese` > 90

若是须要事先组装数组查询条件，可使用：

$map[] = ['name','like','think'];
$map[] = ['status','=',1];

数组的各类查询方式其实能够多样应用

字符串传递

使用字符串条件直接查询和操做，例如：

Db::table('think_user')->where('type=1 AND status=1')->select();

最后生成的SQL语句是

SELECT * FROM think_user WHERE type=1 AND status=1

这里的where多样运用须要开发者按照本身的喜爱和实际的开发需求决定如何使用；若是没法运用就直接使用原生！

table

table方法主要用于指定操做的数据表。

Db::table('think_user')->where('status>1')->select(); // 指定数据表
Db::table('db_name.think_user')->where('status>1')->select(); //指定数据库和表

若是须要对多表进行操做，能够这样使用：

Db::field('user.name,role.title')
->table('think_user user,think_role role')
->limit(10)->select();

为了尽可能避免和mysql的关键字冲突，能够建议使用数组方式定义，例如：

Db::field('user.name,role.title')
->table(['think_user'=>'user','think_role'=>'role'])
->limit(10)->select();

使用数组方式定义的优点是能够避免由于表名和关键字冲突而出错的状况。

alias

alias用于设置当前数据表的别名，便于使用其余的连贯操做；例如join方法等。

示例：

Db::table('think_user')
->alias('a')
->join('think_dept b ','b.user_id= a.id')
->select();

最终生成的SQL语句相似于：

SELECT * FROM think_user a INNER JOIN think_dept b ON b.user_id= a.id

field

field方法主要做用是标识要返回或者操做的字段，能够用于查询和写入操做。

指定字段：field()能够在查询数据、添加数据中均可以运用到，可是在添加中不得违背SQL的规范

$data = Db::table('tp_book')
    ->where('user_id','>','50')
    ->field('title')
    ->select();
// ==> SELECT `title` FROM `tp_book` WHERE `user_id` > 50

使用SQL函数

$data = Db::table('tp_one')
    ->field('SUM(math)')
    ->select();
// ==> SELECT SUM(math) FROM `tp_one`

field方法的参数能够支持数组，例如：

Db::table('think_user')->field(['id','title','content'])->select();

字段排除：排除某一个或多个字段，须要在field()的第二参数设置为True默认Falst

// 排除某一个或多个字段，须要在field()的第二参数设置为True  不支持跨表和join操做。
$data = Db::table('tp_book')->field('user_id',true)->select();
// ==> SELECT `id`,`title` FROM `tp_book`
$data = Db::table('tp_book')->field('id,user_id',true)->select();
// ==>   SELECT `title` FROM `tp_book`

strict

strict方法用于设置是否严格检查字段名，用法以下：（建议true）

// 关闭字段严格检查
Db::name('user')
    ->strict(false)
    ->insert($data);

注意，系统默认值是由数据库配置参数fields_strict决定，所以修改数据库配置参数能够进行全局的严格检查配置，以下：

// 关闭严格检查字段是否存在
'fields_strict'  => false,

若是开启字段严格检查的话，在更新和写入数据库的时候，一旦存在非数据表字段的值，则会抛出异常。

limit

limit()用于限制输入输出的数据条数，也能够指定输出的行数范围

// limit() 能够指定输出的条数、行数范围、输入的条数限制
$data = Db::table('tp_book')->field('title')->limit(3)->select(); //限制条数
// ==>  SELECT `title` FROM `tp_book` LIMIT 3
$data = Db::table('tp_book')->field('title')->limit(3,3)->select(); // 实现分页
// ==> SELECT `title` FROM `tp_book` LIMIT 3,3 //limit(起始行,条数)

limit方法也能够用于写操做，例如更新知足要求的3条数据：

Db::table('think_user')
->where('score',100)
->limit(3)
->update(['level'=>'A']);

page

page()方法主要用于分页查询。

// page() 分页查询
$data = Db::table('tp_book')->field('title')->page(1,3)->select();
// =>  SELECT `title` FROM `tp_book` LIMIT 0,3
$data = Db::table('tp_book')->field('title')->page(2,3)->select();
// =>  SELECT `title` FROM `tp_book` LIMIT 3,3

page()直接是规定第一页第二页便可，page()方法自动实现LIMIT的分页补充……而当LIMIT和page同时出现的话，page接受的一个参数表明页数，而limit的参数表明输出的每页条数。(具体见手册)

order

order()方法用于对操做的结果排序或者优先级限制。(参考手册)

Db::table('think_user')
->where('status', 1)
->order('id', 'desc')
->limit(5)
->select();
 SELECT * FROM `think_user` WHERE `status` = 1 ORDER BY `id` desc LIMIT 5

若是没有指定desc或者asc排序规则的话，默认为asc。

支持使用数组对多个字段的排序，例如：

Db::table('think_user')
->where('status', 1)
->order(['order','id'=>'desc'])
->limit(5)
->select();

最终的查询SQL多是

SELECT * FROM `think_user` WHERE `status` = 1 ORDER BY `order`,`id` desc LIMIT 5

对于更新数据或者删除数据的时候能够用于优先级限制

Db::table('think_user')
->where('status', 1)
->order('id', 'desc')
->limit(5)
->delete();

生成的SQL

DELETE FROM `think_user` WHERE `status` = 1 ORDER BY `id` desc LIMIT 5

在V5.1.7+版本开始，若是你须要在order方法中使用mysql函数的话，必须使用下面的方式：

Db::table('think_user')
->where('status', 1)
->orderRaw("field(name,'thinkphp','onethink','kancloud')")
->limit(5)
->select();

group

GROUP方法一般用于结合合计函数，根据一个或多个列对结果集进行分组。(参考手册)

group方法只有一个参数，而且只能使用字符串。

例如，咱们都查询结果按照用户id进行分组统计：

Db::table('think_user')
    ->field('user_id,username,max(score)')
    ->group('user_id')
    ->select();

生成的SQL语句是：

SELECT user_id,username,max(score) FROM think_score GROUP BY user_id

也支持对多个字段进行分组，例如：

Db::table('think_user')
    ->field('user_id,test_time,username,max(score)')
    ->group('user_id,test_time')
    ->select();

生成的SQL语句是：

SELECT user_id,test_time,username,max(score) FROM think_user GROUP BY user_id,test_time

having

HAVING方法用于配合group方法完成从分组的结果中筛选（一般是聚合条件）数据。

having方法只有一个参数，而且只能使用字符串，例如：

Db::table('think_user')
    ->field('username,max(score)')
    ->group('user_id')
    ->having('count(test_time)>3')
    ->select();

生成的SQL语句是：

SELECT username,max(score) FROM think_score GROUP BY user_id HAVING count(test_time)>3

ThinkPHP5.1学习笔记 数据库操做

数据库

数据库链接

查询控制器(数据库操做)

查询数据

链式查询简单认识

增删改操做

新增数据

修改数据

删除数据

查询表达式

比较查询

区间查询(建议使用快捷)

EXP:其它查询

时间查询

聚合查询

子查询

原生查询

query()/读操做

execute()/写操做

链式查询-建议参考手册

where

table

alias

field

strict

limit

page

order

group

having

ThinkPHP5.1学习笔记数据库操做