thinkphp5——数据库

1 连接数据库（这里在配置文件里配置）

用的配置方式是在应用目录或者模块目录下面的database.php中添加下面的配置参数：

return [
    // 数据库类型
    'type'        => 'mysql',
    // 数据库连接DSN配置
    'dsn'         => '',
    // 服务器地址
    'hostname'    => '127.0.0.1',
    // 数据库名
    'database'    => 'thinkphp',
    // 数据库用户名
    'username'    => 'root',
    // 数据库密码
    'password'    => '',
    // 数据库连接端口
    'hostport'    => '',
    // 数据库连接参数
    'params'      => [],
    // 数据库编码默认采用utf8
    'charset'     => 'utf8',
    // 数据库表前缀
    'prefix'      => 'think_',
    // 数据库调试模式
    'debug'       => false,
    // 数据库部署方式:0 集中式(单一服务器),1 分布式(主从服务器)
    'deploy'      => 0,
    // 数据库读写是否分离 主从式有效
    'rw_separate' => false,
    // 读写分离后 主服务器数量
    'master_num'  => 1,
    // 指定从服务器序号
    'slave_no'    => '',
    // 是否严格检查字段是否存在
    'fields_strict'  => true,    
];

2 原生操作

先引入Db类

use think\Db;

配置了数据库连接信息后，我们就可以直接使用数据库运行原生SQL操作了，支持query（查询操作）和execute（写入操作）方法，并且支持参数绑定。

Db::query('select * from think_user where id=?',[8]);
Db::execute('insert into think_user (id, name) values (?, ?)',[8,'thinkphp']);

也支持命名占位符绑定，例如：

Db::query('select * from think_user where id=:id',['id'=>8]);
Db::execute('insert into think_user (id, name) values (:id, :name)',['id'=>8,'name'=>'thinkphp']);

3 基本查询(如果有返回值，都是数组，find()返回一维数组 select() 返回二维数组)

查询一个数据使用：

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

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

查询数据集使用：

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

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

4 添加数据

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

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

如果你在database.php配置文件中配置了数据库前缀(prefix)，那么可以直接使用 Db 类的 name 方法提交数据

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

insert 方法添加数据成功返回添加成功的条数，insert 正常情况返回 1

添加数据后如果需要返回新增数据的自增主键，可以使用getLastInsID方法：

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

或者直接使用insertGetId方法新增数据并返回主键值：

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

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

添加多条数据

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

$data = [
    ['foo' => 'bar', 'bar' => 'foo'],
    ['foo' => 'bar1', 'bar' => 'foo1'],
    ['foo' => 'bar2', 'bar' => 'foo2']
];
Db::name('user')->insertAll($data);

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

5 修改数据（where里写条件，update里写内容）

更新数据表中的数据

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

如果数据中包含主键，可以直接使用：

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

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

如果要更新的数据需要使用SQL函数或者其它字段，可以使用下面的方式：

Db::table('think_user')
    ->where('id', 1)
    ->update([
        'login_time'  => ['exp','now()'],
        'login_times' => ['exp','login_times+1'],
    ]);

V5.0.18+版本开始是数组中使用exp查询和更新的话，必须改成下面的方式：

Db::table('think_user')
    ->where('id', 1)
    ->update([
        'login_time'  => Db::raw('now()'),
        'login_times' => Db::raw('login_times+1'),
    ]);

更新某个字段的值：

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

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

自增或自减一个字段的值

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秒，给score字段增加1

Db::table('think_user')->where('id', 1)->setInc('score', 1, 10);

setInc/setDec 方法返回影响数据的条数

6 删除数据

删除数据表中的数据

// 根据主键删除
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();

delete 方法返回影响数据的条数，没有删除返回 0

7 查询方法

`where`方法

可以使用where方法进行AND条件查询：

Db::table('think_user')
    ->where('name','like','%thinkphp')
    ->where('status',1)
    ->find();

多字段相同条件的AND查询可以简化为如下方式：

Db::table('think_user')
    ->where('name&title','like','%thinkphp')
    ->find();

`whereOr`方法

使用whereOr方法进行OR查询：

Db::table('think_user')
    ->where('name','like','%thinkphp')
    ->whereOr('title','like','%thinkphp')
    ->find();

多字段相同条件的OR查询可以简化为如下方式：

Db::table('think_user')
    ->where('name|title','like','%thinkphp')
    ->find();

混合查询

where方法和whereOr方法在复杂的查询条件中经常需要配合一起混合使用，下面举个例子：

$result = Db::table('think_user')->where(function ($query) {
    $query->where('id', 1)->whereor('id', 2);
})->whereOr(function ($query) {
    $query->where('name', 'like', 'think')->whereOr('name', 'like', 'thinkphp');
})->select();

生成的sql语句类似于下面：

SELECT * FROM `think_user` WHERE  (  `id` = 1 OR `id` = 2 ) OR (  `name` LIKE 'think' OR `name` LIKE 'thinkphp' )

注意闭包查询里面的顺序，而且第一个查询方法用where或者whereOr是没有区别的。

`getTableInfo`方法

使用getTableInfo可以获取表信息，信息类型包括 fields,type,bind,pk，以数组的形式展示，可以指定某个信息进行获取

// 获取`think_user`表所有信息
Db::getTableInfo('think_user');
// 获取`think_user`表所有字段
Db::getTableInfo('think_user', 'fields');
// 获取`think_user`表所有字段的类型
Db::getTableInfo('think_user', 'type');
// 获取`think_user`表的主键
Db::getTableInfo('think_user', 'pk');

8 查询语法

查询表达式支持大部分的SQL查询语法，也是ThinkPHP查询语言的精髓，查询表达式的使用格式：

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

表达式不分大小写，支持的查询表达式有下面几种，分别表示的含义是：

表达式	含义
EQ、=	等于（=）
NEQ、<>	不等于（<>）
GT、>	大于（>）
EGT、>=	大于等于（>=）
LT、<	小于（<）
ELT、<=	小于等于（<=）
LIKE	模糊查询
[NOT] BETWEEN	（不在）区间查询
[NOT] IN	（不在）IN 查询
[NOT] NULL	查询字段是否（不）是NULL
[NOT] EXISTS	EXISTS查询
EXP	表达式查询，支持SQL语法
> time	时间比较
< time	时间比较
between time	时间比较
notbetween time	时间比较

9 链式操作：

连贯操作	作用	支持的参数类型
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），其中带*标识的表示支持多次调用。

10 聚合查询

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

例子：

Db::table('think_user')->count();

11 时间查询

使用`where`方法

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

// 大于某个时间
where('create_time','> time','2016-1-1');
// 小于某个时间
where('create_time','<= time','2016-1-1');
// 时间区间查询
where('create_time','between time',['2015-1-1','2016-1-1']);

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

使用`whereTime`方法

whereTime方法提供了日期和时间字段的快捷查询，示例如下：

// 大于某个时间
Db::table('think_user')->whereTime('birthday', '>=', '1970-10-1')->select();
// 小于某个时间
Db::table('think_user')->whereTime('birthday', '<', '2000-10-1')->select();
// 时间区间查询
Db::table('think_user')->whereTime('birthday', 'between', ['1970-10-1', '2000-10-1'])->select();
// 不在某个时间区间
Db::table('think_user')->whereTime('birthday', 'not between', ['1970-10-1', '2000-10-1'])->select();

时间表达式

还提供了更方便的时间表达式查询，例如：

// 获取今天的博客
Db::table('think_blog') ->whereTime('create_time', 'today')->select();
// 获取昨天的博客
Db::table('think_blog')->whereTime('create_time', 'yesterday')->select();
// 获取本周的博客
Db::table('think_blog')->whereTime('create_time', 'week')->select();   
// 获取上周的博客
Db::table('think_blog')->whereTime('create_time', 'last week')->select();    
// 获取本月的博客
Db::table('think_blog')->whereTime('create_time

12 高级查询

快捷查询方式是一种多字段相同查询条件的简化写法，可以进一步简化查询条件的写法，在多个字段之间用|分割表示OR查询，用&分割表示AND查询，可以实现下面的查询，例如：

Db::table('think_user')
    ->where('name|title','like','thinkphp%')
    ->where('create_time&update_time','>',0)
    ->find();

生成的查询SQL是：

SELECT * FROM `think_user` WHERE ( `name` LIKE 'thinkphp%' OR `title` LIKE 'thinkphp%' ) AND ( `create_time` > 0 AND `update_time` > 0 ) LIMIT 1

快捷查询支持所有的查询表达式。

区间查询

区间查询是一种同一字段多个查询条件的简化写法，例如：

Db::table('think_user')
    ->where('name',['like','thinkphp%'],['like','%thinkphp'])
    ->where('id',['>',0],['<>',10],'or')
    ->find();

生成的SQL语句为：

SELECT * FROM `think_user` WHERE ( `name` LIKE 'thinkphp%' AND `name` LIKE '%thinkphp' ) AND ( `id` > 0 OR `id` <> 10 ) LIMIT 1

区间查询的查询条件必须使用数组定义方式，支持所有的查询表达式。

下面的查询方式是错误的：

Db::table('think_user')
    ->where('name',['like','thinkphp%'],['like','%thinkphp'])
    ->where('id',5,['<>',10],'or')
    ->find();

批量查询

可以进行多个条件的批量条件查询定义，例如：

Db::table('think_user')
    ->where([
        'name'  =>  ['like','thinkphp%'],
        'title' =>  ['like','%thinkphp'],
        'id'    =>  ['>',0],
        'status'=>  1
    ])
    ->select();

生成的SQL语句为：

SELECT * FROM `think_user` WHERE `name` LIKE 'thinkphp%' AND `title` LIKE '%thinkphp' AND `id` > 0 AND `status` = '1'

闭包查询

Db::table('think_user')->select(function($query){
    $query->where('name','thinkphp')
        ->whereOr('id','>',10);
});

生成的SQL语句为：

SELECT * FROM `think_user` WHERE `name` = 'thinkphp' OR `id` > 10

使用Query对象查询

也可以事先封装Query对象，并传入select方法，例如：

$query = new \think\db\Query;
$query->name('user')
    ->where('name','like','%think%')
    ->where('id','>',10)
    ->limit(10);
Db::select($query);

如果使用Query对象的话，select方法之前调用的任何的链式操作都是无效。

混合查询

可以结合前面提到的所有方式进行混合查询，例如：

Db::table('think_user')
    ->where('name',['like','thinkphp%'],['like','%thinkphp'])
    ->where(function($query){
        $query->where('id',['<',10],['>',100],'or');
    })
    ->select();

生成的SQL语句是：

SELECT * FROM `think_user` WHERE ( `name` LIKE 'thinkphp%' AND `name` LIKE '%thinkphp' ) AND ( `id` < 10 or `id` > 100 )

字符串条件查询

对于一些实在复杂的查询，也可以直接使用原生SQL语句进行查询，例如：

Db::table('think_user')
    ->where('id > 0 AND name LIKE "thinkphp%"')
    ->select();

为了安全起见，我们可以对字符串查询条件使用参数绑定，例如：

Db::table('think_user')
    ->where('id > :id AND name LIKE :name ',['id'=>0, 'name'=>'thinkphp%'])
    ->select();

V5.0.4+开始，ThinkPHP支持对同一个字段多次调用查询条件，例如：

Db::table('think_user')
    ->where('name','like','%think%')
    ->where('name','like','%php%')
    ->where('id','in',[1,5,80,50])
    ->where('id','>',10)
    ->find();

快捷方法（`V5.0.5+`）

V5.0.5+版本开始新增了一系列快捷方法，用于简化查询，包括：

方法	作用
`whereNull`	查询字段是否为Null
`whereNotNull`	查询字段是否不为Null
`whereIn`	字段IN查询
`whereNotIn`	字段NOT IN查询
`whereBetween`	字段BETWEEN查询
`whereNotBetween`	字段NOT BETWEEN查询
`whereLike`	字段LIKE查询
`whereNotLike`	字段NOT LIKE查询
`whereExists`	EXISTS条件查询
`whereNotExists`	NOT EXISTS条件查询
`whereExp`	表达式查询

13 子查询

首先构造子查询SQL，可以使用下面三种的方式来构建子查询。

1、使用`select`方法

当select方法的参数为false的时候，表示不进行查询只是返回构建SQL，例如：

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

生成的subQuery结果为：

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

2、使用`fetchSql`方法

fetchSql方法表示不进行查询而只是返回构建的SQL语句，并且不仅仅支持select，而是支持所有的CURD查询。

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

生成的subQuery结果为：

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

3、使用`buildSql`构造子查询

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

生成的subQuery结果为：

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

调用buildSql方法后不会进行实际的查询操作，而只是生成该次查询的SQL语句（为了避免混淆，会在SQL两边加上括号），然后我们直接在后续的查询中直接调用。

需要注意的是，使用前两种方法需要自行添加‘括号’。

然后使用子查询构造新的查询：

Db::table($subQuery.' a')
    ->where('a.name','like','thinkphp')
    ->order('id','desc')
    ->select();

生成的SQL语句为：

SELECT * FROM ( SELECT `id`,`name` FROM `think_user` WHERE `id` > 10 ) a WHERE a.name LIKE 'thinkphp' ORDER BY `id` desc

4、使用闭包构造子查询

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();

生成的SQL语句是

SELECT * FROM `think_user` WHERE `id` IN ( SELECT `id` FROM `think_profile` WHERE `status` = 1 )

Db::table('think_user')
->where(function($query){
    $query->table('think_profile')->where('status',1);
},'exists')
->find();

生成的SQL语句为

SELECT * FROM `think_user` WHERE EXISTS ( SELECT * FROM `think_profile` WHERE `status` = 1 )

V5.0.9+版本开始，比较运算也支持使用闭包子查询