GVKun编程网logo

laravel - 使用查询构造器进行数据的增删改查（laravel查询数据库）

27

如果您想了解laravel-使用查询构造器进行数据的增删改查和laravel查询数据库的知识，那么本篇文章将是您的不二之选。我们将深入剖析laravel-使用查询构造器进行数据的增删改查的各个方面，并

如果您想了解laravel - 使用查询构造器进行数据的增删改查和laravel查询数据库的知识，那么本篇文章将是您的不二之选。我们将深入剖析laravel - 使用查询构造器进行数据的增删改查的各个方面，并为您解答laravel查询数据库的疑在这篇文章中，我们将为您介绍laravel - 使用查询构造器进行数据的增删改查的相关知识，同时也会详细的解释laravel查询数据库的运用方法，并给出实际的案例分析，希望能帮助到您！

本文目录一览：

laravel - 使用查询构造器进行数据的增删改查（laravel查询数据库）

laravel - 使用查询构造器进行数据的增删改查（laravel查询数据库）

1. 插入数据 ->insert()

 // 使用查询构造器query builder 插入数据
        $bools = DB::table('student')->insert(['name'=>'sean', 'age'=>18]);
        var_dump($bools);

        // 插入多条数据
        $bools = DB::table('student')->insert([
            ['name'=>"jean", 'age'=>10],
            ['name'=>'kate', 'age'=>27],
        ]);
        var_dump($bools);

        // 插入的同时返回id
        $id = DB::table('student')->insertGetId(['name'=>'lilei', 'age'=>30]);
        var_dump($id);

2. 更改数据 -> update()

 // 使用查询构造器query builder 更新数据

        // 更新一条数据
        $num = DB::table('student')->where('id',1003)->update(['name'=>'hanmeimei']);
        var_dump($num);

        // 自增（将某列加上一个数，默认是 +1 ）
        $num = DB::table('student')->where('id', 1003)->increment('age', 10);
        var_dump($num);

        // 自减 （将某列减去一个数， 默认是-1）
        $num = DB::table('student')->where('id', 1003)->decrement('age', 3);
        var_dump($num);

        // 自增的同时，修改其他列的内容
        $num = DB::table('student')->where('id', 1003) -> increment('age', 3, ['name'=>'tony']);
        var_dump($num);

flask实现简单数据的增删改查（蓝图）

flask实现简单数据的增删改查（蓝图）

main文件为主文件，实现蓝图的引入与注册

from flask import Flask
from add_Flask import add
from del_Flask import dele
from select_Flask import select
from update_Flask import update

def flask_app():
    app=Flask(__name__)
    app.register_blueprint(add.add)         #对蓝图进行注册
    app.register_blueprint(dele.dele)
    app.register_blueprint(select.select)
    app.register_blueprint(update.update)
    return app
    #以函数方式返回app对象

flask_app().run(debug=True)

data文件存放列表数据：

STUDENT = [
    {''id'': 1, ''name'': ''王小璐'', ''age'': 18, ''gender'': ''女''},
    {''id'': 2, ''name'': ''李晓芬'', ''age'': 21, ''gender'': ''女''},
    {''id'': 3, ''name'': ''陈志鹏'', ''age'': 24, ''gender'': ''男''},
    {''id'': 4, ''name'': ''胡歌'', ''age'': 35, ''gender'': ''男''},
    {''id'': 5, ''name'': ''赵安琪'', ''age'': 28, ''gender'': ''女''},
]

添加数据蓝图：

from flask import Blueprint,request,redirect,render_template
from blueview.flask_Data import STUDENT

add=Blueprint(''add'',__name__,template_folder="temp",static_folder=''static'')

@add.route(''/add'',methods=[''GET'',''POST''])
def add_view():
    if request.method==''POST'':
        stu_dic={
            ''id'':request.form.get(''id''),
            ''name'':request.form.get(''name''),
            ''age'':request.form.get(''age''),
            ''gender'':request.form.get(''gender'')
        }
        STUDENT.append(stu_dic)
        return redirect(''/select'')
    return render_template(''add.html'')
add蓝图 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <link rel="stylesheet" href="/static/bootstrap/css/bootstrap.min.css">
    <title>添加学生</title>
</head>
<body>
<script src="/static/jquery-3.3.1.min.js"></script>
<script src="/static/bootstrap/js/bootstrap.min.js"></script>

<form method="post" class="form-horizontal" style="margin-top: 50px">
    <div class="form-group">
        <label for="inputID" class="col-sm-2 control-label">编号:</label>
        <div class="col-sm-4">
            <input type="text" class="form-control" name="id" placeholder="">
        </div>
    </div>
    <div class="form-group">
        <label for="inputNAME" class="col-sm-2 control-label">姓名:</label>
        <div class="col-sm-4">
            <input type="text" class="form-control" name="name" placeholder="">
        </div>
    </div>
    <div class="form-group">
        <label for="inputAGE" class="col-sm-2 control-label">年龄:</label>
        <div class="col-sm-4">
            <input type="text" class="form-control" name="age" placeholder="">
        </div>
    </div>
    <div class="form-group">
        <label for="inputGENDER" class="col-sm-2 control-label">性别:</label>
        <div class="col-sm-4">
            <input type="text" class="form-control" name="gender" placeholder="">
        </div>
    </div>

    <div class="form-group">
        <label class="col-sm-2 control-label"></label>
        <div class="col-sm-4">
            <input class="btn btn-success" type="submit" value="添加学生">
        </div>
    </div>

</form>

</body>
</html>
add.html

删除数据蓝图：

from flask import Blueprint,render_template
from blueview.flask_Data import STUDENT

dele=Blueprint(''dele'',__name__,template_folder="temp",static_folder=''static'')

@dele.route(''/dele/<int:nid>'',methods=[''GET'',''POST''])
def del_view(nid):
    # print(nid)
    ST=[]
    for stu in STUDENT:
        if stu["id"]==nid:
            pass
        else:
            ST.append(stu)
    return render_template(''select.html'',student=ST)
dele蓝图 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <link rel="stylesheet" href="/static/bootstrap/css/bootstrap.min.css">
    <title>学生信息</title>
</head>
<body>
<script src="/static/jquery-3.3.1.min.js"></script>
<script src="/static/bootstrap/js/bootstrap.min.js"></script>

<table class="table table-bordered">
    <thead>
    <tr>
        <th>编号</th>
        <th>姓名</th>
        <th>年龄</th>
        <th>性别</th>
        <th colspan="2" rowspan="1" style=''text-align: center;''>编辑</th>
    </tr>
    </thead>
    <tbody>
    {% for st in student %}
        <tr>
        <td>{{ st.id }}</td>
        <td>{{ st.name }}</td>
        <td>{{ st.age }}</td>
        <td>{{ st.gender }}</td>
        <td><a href="/update/{{ st.id }}"  class="btn btn-primary">修改</a> </td>
        <td><a href="/dele/{{ st.id }}"  class="btn btn-danger">删除</a></td>
        </tr>
    {% endfor %}

    </tbody>

</table>
<a href="/add"  class="btn btn-success">添加学生</a>
</body>
</html>
dele.html

更新数据蓝图：

from flask import Blueprint,request,redirect,render_template
from blueview.flask_Data import STUDENT

update=Blueprint(''update'',__name__,template_folder=''temp'',static_folder=''static'')

@update.route(''/update/<int:nid>'',methods=[''GET'',''POST''])
def update_view(nid):
    print(nid)
    if request.method==''POST'':
        stu_dic={
            ''id'':request.form.get(''id''),
            ''name'': request.form.get(''name''),
            ''age'': request.form.get(''age''),
            ''gender'': request.form.get(''gender'')
        }

        for index,stu in enumerate(STUDENT):
            if stu[''id'']==int(stu_dic[''id'']):
                STUDENT[index]=stu_dic
        return redirect(''/select'')

    for stu in STUDENT:
        if stu[''id'']==int(nid):
            return render_template(''update.html'',student=stu)

    return render_template("update.html", student="")
update蓝图 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>学生列表</title>
</head>
<body>
<form method="post">
    <input type="text" name="id" hidden value="{{ student.id }}"><br>
    姓名:<input type="text" name="name" value="{{ student.name }}"><br>
    年龄:<input type="text" name="age" value="{{ student.age }}"><br>
    性别:<input type="text" name="gender" value="{{ student.gender }}"><br>
    <input type="submit" value="修改信息">
</form>

</body>
</html>
update.html

查询数据蓝图：

from flask import Blueprint,render_template
from blueview.flask_Data import STUDENT

select=Blueprint(''select'',__name__,template_folder="temp",static_folder="static")

@select.route(''/select'')
def select_view():
    return render_template(''select.html'',student=STUDENT)
select蓝图 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <link rel="stylesheet" href="/static/bootstrap/css/bootstrap.min.css">
    <title>学生信息</title>
</head>
<body>
<script src="/static/jquery-3.3.1.min.js"></script>
<script src="/static/bootstrap/js/bootstrap.min.js"></script>

<table class="table table-bordered">
    <thead>
    <tr>
        <th>编号</th>
        <th>姓名</th>
        <th>年龄</th>
        <th>性别</th>
        <th colspan="2" rowspan="1" style=''text-align: center;''>编辑</th>
    </tr>
    </thead>
    <tbody>
    {% for st in student %}
        <tr>
        <td>{{ st.id }}</td>
        <td>{{ st.name }}</td>
        <td>{{ st.age }}</td>
        <td>{{ st.gender }}</td>
        <td><a href="/update/{{ st.id }}"  class="btn btn-primary">修改</a> </td>
        <td><a href="/dele/{{ st.id }}"  class="btn btn-danger">删除</a></td>
        </tr>
    {% endfor %}
    
    </tbody>

</table>
<a href="/add"  class="btn btn-success">添加学生</a>
</body>
</html>
select.html

项目的完整文件结构为：

其中static为静态资源文件夹

实现的效果图如下:

Laravel - 使用查询构造器查询

Laravel - 使用查询构造器查询

public function constructorQuery()     {         # 1,新增         DB::table('student')->insert([             ['name' => '王者之锤', 'age' => 18],             ['name' => '地狱之眼', 'age' => 30]         ]); 　　# .....      }

laravel - 查询构造器

laravel - 查询构造器

获取数据

1，从数据表中获取所有行

<?php

class UserController extends Controller{

       public function index(){

                  $users = DB::table(''users'')->get();

      }

}

从数据表中获取一行数据你可以使用 first() 方法。该方法返回一个 stdclass 对象

$user = DB::table("users")->where(“name”,"John")->first()

如果不需要正行数据，则可以使用 value() 方法从记录中获取单个值。该方法直接返回该字段得值：

$email = DB::table(''users'')->where("name","John")->value("email");

获取一列得值，则可以使用 pluck() 方法。在下面得例子中，我们将获取角色表中得标题得集合

$titles = DB::table("roles")->pluck("title");

foreach($titles as $title){

       echo $title;  

}

你还可以在返回得集合中指定字段得自定义键值：

$roles = DB::table("roles")->pluck("title","name")

foreach($roles as $name=>$title){

            echo $title;

}

2, 分块结果

如果你需要处理上千条数据库记录。你可以考虑使用 chunk 方法。该方法一次获取结果集得一小块，并将其传递给 闭包 函数进行处理。该方法在 Artisan 命令 编写数千条处理数据得时候非常有用。力图我们可以将全部表数据切割成一次处理 100 条记录得一小块：

DB::table("users)->orderBy("id")->chunk(100,function($users){

          foreach($users as $user){

          }

})

你可以通过在 闭包 中返回 false 来终止继续获取分块结果：

DB::table(''users'')->orderBy(''id'')->chunk(100,function(){

        return false;

})

聚合

查询构造器还提供了各种聚合方法，比如 count 、max 、min 、 avg 还有 sum。 你可以在构造查询后调用任何方法：

$user = DB:table("users")->count():

$price = DB::table(''orders'')->max("price");

当然，你也可以将这些聚合方法和其他得查询语句结合：

$price = DB::table(''orders'')->where("finalized",1)->avg(''price'');

3, 判断记录是否存在

除了 count 方法可以确定查询条件得结果是否存在之外，还可以使用 exists 和 doesntExist 方法：

return DB::table(''orders'')->where("finalized",1)->exists();

return DB::table("orders")->where(''finalized'',1)->doesntExist();

selects 语句

指定一个 select 语句

当然你可能并不总是希望从数据表中获取所有列。使用 select  方法，你可以自定义一个 select 查询语句来查询指定的字段：

$users = DB::table(''users'')->select("name","emal as user_email ")->get();

distinct 方法会强制让查询返回得结果不重复：

$users = DB::table(''users'')->distinct()->get();

如果你已经有了一个查询构造器实例，并且希望在现有得查询语句中加入一个字段，那么你可以使用 addSelect 方法

$query = DB::table(''users'')->select(''name'');

$users = $query->addSelect(''age'')->get();

4，原生表达式

有时候你可能需要在查询中使用原生表达式。你可以使用 DB:raw 创建一个原生表达式：

$users = DB::table(''users'')

              ->select(DB::raw(‘count(*) as user_count , status ’))

              ->where(''status'' , ''<>'' , 1)

               ->groupBy("status")

               ->get();

注：原生表达式将会被当做字符串注入到查询中，因此你应该小心使用，避免创建 SQL 注入得漏洞

原生方法

可以使用以下方法代替 DB::raw  , 将原生表达式插入查询得各个部分。

selectRow 方法可以代替 select (DB::raw (...))。该方法得第二个参数是可选项，值是一个绑定参数得数组：

$order = DB::table(''orders'')

               ->selectRaw(''price * ? as price_with_tax '' , [1.0825])

               ->get();

whereRaw/orWhereRaw

whereRaw 和 orWhereRaw 方法将原生得 where

注入到你得查询中。这两个方法得第二个参数还是可选项，值还是绑定参数得数组：

$orders = DB::table(''orders'')

                ->whereRaw('' price > IF(state = "TX" , ? , 100) '' , [200] )

                ->get();

内连接（等值连接） json 方法，json 方法得第一个参数是你需要连接到得表名，剩余得其他参数则是为连接指定得列约束

$order = Orders::select("order_goods.order_id","user_name","order_sn","goods_name")
         ->join("users","ecs_users.user_id","=","order_info.user_id")
         ->join("order_goods","order_info.order_id","=","order_goods.order_id")
         ->get();
左连接 leftJoin方法，用法和join一样
$order_user = Orders::select("order_sn","user_name")
     ->leftJoin("users","users.user_id","=","order_info.user_id")
    ->get();

交叉连接 crossJoin 方法，传递你想要交叉连接得表名到该方法即可。交叉连接在第一张表和被连接表之间生成一个笛卡尔积：
$cross_list = Orders::crossJoin("ecs_users")->get();
高级连接语句 
你还可以指定更多得高级连接子句，传递一个闭包到join
where子句 可以添加where子句到查询中，调用where最基本得方式需要传递三个参数，第一个参数是列名，第二个参数是任意一个数据库支持得操作符，，
第三个参数是该列要比较得值
$user = Users::where("is_status",">=","2")
    ->get()->toArray();

为了方便，如果只是简单比较列值和给定数值是否相等，可以将数值直接作为where方法得第二个参数
$user = Users::where("is_status","2")
    ->get()->toArray();
还可以传递条件数组到where函数
$user = Users::where([["is_status",">=",2],["is_forten",">" ,0]])->get()->toArray();
or语句
你可以通过方法链将多个约束连接到一起，也可以添加or子句到查询，orwhere方法和where方法接收参数一样：
$user = Users::select(''user_name'',"is_status")->where("is_status",1)
    ->orWhere("is_status",2)
    ->orderBy("user_id"," desc")
    ->get()->toArray();
更多的where子句
whereBetween 方法验证列值是否在给定值之间
$user = Users::select(''user_name'',"is_status")
    ->whereBetween("is_status",[1,2])
    ->get()->toArray();
whereNotBetween 方法验证列值不在给定值之间
$user = Users::select(''user_name'',"is_status")
    ->whereNotBetween("is_status",[1,2])
    ->get()->toArray();
whereIn/whereNotIn
whereIn 方法验证给定列的值是否在给定数组中
$user = Users::select(''user_name'',"is_status")
    ->whereIn("is_status",[1,2])
    ->get()->toArray();
whereNotIn 方法验证给定列的值不在给定数组中
$user = Users::select(''user_name'',"is_status")
    ->whereNotIn("is_status",[1,2])
    ->get()->toArray();
whereNUll/whereNotNull
whereNull 方法验证给定列的值为Null
$user = Users::select(''user_name'',"is_status")
    ->whereNull("is_forten")
    ->get()->toArray();
whereNotNUll 方法验证给定列的值不是NUll
$user = Users::select(''user_name'',"is_status","is_forten")
    ->whereNotNull("is_forten")
    ->get()->toArray();
whereDate/whereMonth/WhereDay/whereYear/WhereTime
whereDate 方法用于比较字段值和日期
$user = Users::select(''user_name'',"is_status","is_forten")
    ->whereDate("last_time","2019-09-10")
    ->get()->toArray();
whereMonth 方法用于比较字段值和一年中的指定月份
$user = Users::select(''user_name'',"is_status","is_forten")
    ->whereMonth("last_time","9")
    ->get()->toArray();
whereDay 方法用于比较字段和一月中的指定日期
$user = Users::select(''user_name'',''last_time'')
    ->whereDay("last_time","24")
    ->get()->toArray();
whereYear 方法用于比较字段值和一月中的指定日期
$user = Users::select(''user_name'',''last_time'')
    ->whereYear("last_time","2017")
    ->get()->toArray();
whereTime 方法用于比较字段值和指定时间
$user = Users::select(''user_name'',''last_time'')
    ->whereTime("last_time","=","10:24")
    ->get()->toArray();
whereColumn 方法用于验证两个字段是否相等
$user = Users::select(''user_name'',''last_time'')
    ->whereColumn("user_money","frozen_money")
    ->get()->toArray();
whereColumn还可以传递一个比较运算符到该方法：
$user = Users::select(''user_name'',''last_time'')
    ->whereColumn("reg_time",">=","last_login")
    ->get()->toArray();
还可以传递多条件数组到whereColumn 方法，这些条件通过 and 操作符进行链接：
$user = Users::select(''user_name'',''last_time'')
    ->whereColumn([["reg_time",">=","last_login"],
      ["user_money","=","frozen_money"]
    ])
    ->get()->toArray();
参数分组
例：括号中进行分组约束
$user = Users::select(''user_name'',''last_time'')
    ->where("is_status",">","0")
    ->orWhere(function($query){
        $query->where("is_forten",">","0")
        ->whereColumn( [
            ["user_money","=","frozen_money"]
        ]);
    })
    ->get()->toArray();
注：无论何时都需要对orWhere调用进行分组以避免应用全局作用域时出现与预期不符的行为。
排序、分组、限定
orderBy 方法允许你通过给定字段对结果集进行排序，orderBy的第一个参数应该是你希望排序的字段，第二个参数控制着排序的方向
$user = Users::where("is_status",1)
    ->orderBy(''user_id'',"desc")->get();

latest/oldest 方法允许你通过日期对结果进行排序，默认情况下，结果集根据 传入自动进行排序
$user = Users::select("reg_time")
    ->where("is_status",1)
    ->latest(''reg_time'')
    ->first()->toArray();
inRandomOrder 方法可用于对查询结果集进行随机排序，比如，你可以用该方法获取一个随机用户：
$user = Users::select("user_name","reg_time")
    ->where("is_status",1)
    ->inRandomOrder()
    ->get()->toArray();
groupBy/having 方法可用于对查询结果集进行分组， having方法和where方法的用法类似,having后面的二次筛选的参数必须是分组字段或聚合数据
$user = Users::select(user_id,"user_name","reg_time")
    ->groupBy("is_status")
    ->having("is_status",">",0)
    ->get()->toArray();

skip/take 
想要限定查询返回的结果集数目，或者在查询中跳过指定数目的结果，可以使用skip和take方法 
例 跳过10条 取5条
$user = Users::select("user_name","reg_time")
    ->where("is_status",">",0)
    ->skip(10)->take(5)
    ->get()->toArray();
作为替代方法，还可以使用limit和offset方法：
$user = Users::select("user_name","reg_time")
    ->where("is_status",">",0)
    ->offset(10)
    ->limit(5)
    ->get()->toArray();
条件子句
有时候你可能想要某些条件为true时才将条件子句应用到查询。

$sortBy = "reg_time";
$user = Users::select("user_name","reg_time")->when($sortBy,function($query) use ($sortBy){
    return $query->orderBy($sortBy);
},function($query){
    return $query->orderBy("user_name");
})->get()->toArray();
插入（Inert）
insert方法用于插入记录到数据表，insert方法接收数组形式的字段名和字段值进行插入操作：
Users::insert([''email'' => ''john@example.com'', ''votes'' => 0]);
你也可以一次性传入多个数组来插入多条记录，每个数组代表要插入数据表的记录
Users::insert([
    [''email'' => ''taylor@example.com'', ''votes'' => 0],
    [''email'' => ''dayle@example.com'', ''votes'' => 0]
]);
自增ID
如果数据表有自增ID，使用insertGetID方法来插入记录并返回ID值：
更新
update方法和insert方法一样，接收字段名和字段值的键值对数组，对应字段名和字段值的键值对数组
Users::where("user_id",3623)->update([''email''=>''test@qq.com'']);
更新JSON字段

更新json字段的时候，需要使用->语法访问json对象上相应的值，该操作只能用于支持json字段类型的数据库：
Test::where(''id'',1)->update([''option->option''=>''修改'']);

增加/减少（存在减少到负值的坑。。。。）
increment/decrement 这两个方法都至少接收一个参数，需要修改的列。第二个参数是可选的，用于控制列值增加/减少的数目
Test::increment("vote");
Test::increment("vote",8);
Test::decrement(''vote'');
 Test::decrement("vote",5);
在操作过程中你还可以制定额外的列进行更新
删除（delete）
DB::table(''users'')->delete();

DB::table(''users'')->where(''votes'', ''>'', 100)->delete();
如果你希望清除整张表，也就是删除所有列并将自增ID置为0，可以使用truncate 方法
DB::table(''users'')->truncate();
悲观锁&乐观锁
悲观锁：顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，
这样别人想拿这个数据就会阻塞直到它拿到锁。传统的关系型数据库里面用到了很多这种机制，比如行锁、表锁、读锁、写锁等，都是在做操作之前先上锁

乐观锁，顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，
可以使用版本号等机制实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write_condition 机制的其实都是提供的乐观锁

悲观锁使用
laravel查询构建起提供了一些方法帮助你在select语句中实现悲观锁。可以在查询中使用sharedLock方法从而在运行语句时带有一把‘共享锁’。
共享锁可以避免被选择的行被修改直到事务提交：
$test = Test::where("vote","<" , 0)->sharedLock()->get()->toArray();
上面的查询等价于下面这条SQL语句：
select * from test vote>0 lock in share mode

此外你可以使用lockForUpdate方法。 for update  锁避免选择行被其它共享锁修改或删除：
$test = Test::where("vote","<" , 0)->lockForUpdate()->get()->toArray();
上面这个查询等价于下面这条SQl语句
select * from test where vote <0 for update

for update 与 lock in share mode 都是用于确保被选中的记录值不能被其他事务更新（上锁），两者的区别在于
lock in share mode 不会阻塞其它事务读取被锁定行记录的值，而for update 会阻塞其它锁定性读对锁定行的读取
（非锁定性读仍然可以不读取这些记录，lock in share mode 和for update 都是锁定读）

举例说明：在一条语句中读取一个值，然后在另一条语句中更新这个值。使用lock in share mode 的话可以允许两个事务读取相同的初始化值，
所以执行两个事务之后最终计数器的值+1:而如果使用for update 的话，会锁定第二个事务对记录值的读取直到第一个事务执行完成，这样计数器的最终结果就是+2了

乐观锁使用
乐观锁，大多是基于数据版本记录机制实现。所谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个‘version’
字段来实现

总结

两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下，即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果经常产生冲突，上层应用会不断的进行重试，这样反倒是降低了性能，所以这种情况下用悲观锁就比较合适。



注：数据转化  

       把数据转为数组  toArray ()

       把数据转为 json   toJson ()

 https://xueyuanjun.com/post/9577.html

laravel orm进行增删改查

laravel orm进行增删改查

 https://laravelacademy.org/post/9699.html@H_301_1@

建议用DB门面直接操作数据库，因为ORM性能低。数据查询上面，ORM不会比DB差的，就比如with，是用了sql最基本的拆语句优化。ORM的损耗仅仅是代码层面的，这已经不算是问题了。@H_301_1@

ORM适用于一般到中等复杂度的查询，也适用于各种模型操作，比如有一个关系targets，你可以直接用targets()->delete()等等进行关系数据操作。
ORM中的软删除，自动更新时间字段，字段保护，字段类型转换，都会在一些规范而且系统的工程中让你受益。
@H_301_1@

另外DB的场景：一些比较复杂的查询语句，事务操作，等都需要DB来完成。@H_301_1@ 

模型类定义
使用模型类之前，需要在数据库有对应的数据表，因为模型类就是数据表在面向对象编程语言中的映射。比如我们前面几篇教程中用到的 User 模型和 Post 模型都是这样，要创建一个模型类，需要使用 make:model 命令：

PHP artisan make:model Post
注：如果对应的数据表尚未创建，你还可以在创建模型类的同时创建对应的数据库迁移文件，通过 PHP artisan make:model Post -m 即可。如果你想将模型类创建到 app/Models 目录下，可以这么运行上述命令 PHP artisan make:model Models/Post。

接下来我们就是 posts 表映射的 Post 模型为例，来看看默认都有哪些约定。新生成的 Post 模型类如下：

<?PHP

namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    //
}
里面什么东西都没有，但是我们就可以通过它完成数据表记录的增删改查操作了，怎么做到的？这就是「约定优于配置」的功劳了。下面我们就来看看这些默认的约定。

表名
Eloquent 约定模型类映射表名是将类名由驼峰格式转化为小写+下划线（含多个单词的话），最后将其转化为复数形式，比如 Post 对应表名是 posts、PostTag 对应表名是 post_tags 等等。当然，如果你不想遵循这个系统约定的规则，也可以通过手动设置模型类属性的方式进行自定义，例如：

protected $table = 'articles';
主键
Eloquent 默认假设每张数据表都有一个整型的自增主键，其字段名为 id，如果你的数据表主键名不是 id，可以通过 $primaryKey 属性来指定：

protected $primaryKey = 'post_id';
如果主键不是自增的，还可以设置 $incrementing 属性为 false：

public $incrementing = false;
如果主键不是整型，还可以设置 $keyType 属性为 string：

protected $keyType = 'string';
时间戳
Eloquent 默认约定每张表都有 created_at 和 updated_at 字段（迁移类中 $table->timestamps() 会生成这两个字段），并且在保存模型类时会自动维护这两个字段。如果你的数据表里面不包含这两个字段，或者只包含一个，都需要设置 $timestamps 属性为 false：

public $timestamps = false;
或者通过 CREATED_AT 和 UPDATED_AT 常量来设置自定义的创建和更新时间字段：

public const CREATED_AT = 'create_time';
public const UPDATED_AT = 'update_time';
此外，默认时间的存储格式是 Y-m-d H:i:s，你还可以通过 $dateFormat 属性来自定义时间戳的格式，该属性值通过 PHP 的 date() 函数进行解析，所以原则上支持 date 函数支持的所有语法格式，比如将时间设置为 Unix 时间戳：

protected $dateFormat = 'U';
这样，保存到数据库的时间格式就是 Unix 时间戳了，前提是你的 created_at 和 updated_at 字段是整型，否则会报格式错误。

数据库连接
Eloquent 模型类默认约定的数据库连接是 config/database.PHP 中配置的默认连接，正如我们在连接配置教程中所说的那样，如果应用配置了多个数据库连接，可以通过 $connection 属性为模型类指定使用哪个连接：

protected $connection = 'connection_name';
查询数据
日常开发中，大部分操作都是数据库中查询数据，Eloquent 模型了为我们提供了很多方法帮助我们从数据库中获取数据。

获取所有记录
我们可以通过模型类提供的 all 方法获取一张表的所有记录：

$posts = Post:all();
和查询构建器一样，该方法返回的也是集合，只不过是模型类集合：



要获取指定模型类的字段属性，遍历该集合即可：

foreach ($posts as $post) {
    dump($post->title);
}
和查询构建器一样，如果结果集很大的话，模型类也支持通过 chunk 方法分块获取查询结果：

Post::chunk(10, function ($posts) {
   foreach ($posts as $post) {
       if ($post->views == 0) {
           continue;
       } else {
           dump($post->title . ':' . $post->views);
       }
   }
});
除此之外，在 Eloquent 模型中还可以通过 cursor 方法每次只获取一条查询结果，从而最大限度减少内存消耗：

foreach (Post::cursor() as $post) {
    dump($post->title . ':' . $post->content);
}
获取指定查询结果
如果想要指定查询条件和查询字段，可以通过 where 方法和 select 方法来实现：

$posts = Post::where('views', '>', 0)->select('id', 'title', 'content')->get();
对应查询结果如下：



实际上，Eloquent 模型类底层的查询也是基于查询构建器来实现的，你可以在模型类上调用所有查询构建器的 Where 查询方法，同样是以流接口的模式构建方法链调用即可。前面提到的 chunk 和 cursor 方法也适用于这种指定查询条件的查询操作。

因为是查询构建器，所以我们还可以在模型查询操作中对查询结果进行排序和分页：

$posts = Post::where('views', '>', 0)->orderBy('id', 'desc')->offset(10)->limit(5)->get();
对应的返回结果如下：



获取单条记录
当然，你也可以通过查询构建器的方式在模型类查询中获取单条记录：

$user = User::where('name', '学院君')->first();
返回的结果是一个模型类实例：



你可以直接通过 $user->name 这样的方式访问模型类实例的属性。

此外，如果查询的条件是主键 ID 的话，还可以将上述调用简化为通过 find 方法来实现：

$user = User::find(1);
返回结果与上面完全一致。

模型类查询结果为空会返回 null。如果你想要在单条记录返回结果为空时返回 404 响应（在控制器方法中可能需要用到类似操作），可以通过 firstOrFail 或者 findOrFail 方法在找不到对应记录时抛出 404 异常，从而简化代码编写：

$user = User::findOrFail(111);
如果 id=111 的记录在 users 数据表中不存在，就会返回 404 响应：



获取聚合结果
Eloquent 模型类同样支持 count、sum、avg、max、min 等聚合函数查询：

$num = User::whereNotNull('email_verified_at')->count();       # 计数     
$sum = User::whereNotNull('email_verified_at')->sum('id');     # 求和    
$avg = User::whereNotNull('email_verified_at')->avg('id');     # 平均值   
$min = User::whereNotNull('email_verified_at')->min('id');     # 最小值   
$max = User::whereNotNull('email_verified_at')->max('id');     # 最大值   
你会发现，如果你掌握了查询构建器，就等同于掌握了 Laravel 中的所有数据库查询操作。只不过将 DB::table 换成对应的模型类而已。

注：除获取单条记录之外，ELoquent 模型类查询返回的结果都是集合类，因此你可以在查询结果上调用集合类的所有方法，还可以自定义模型对应集合类，详情请查看对应官方文档。

插入数据
通过 Eloquent 模型类插入记录到数据库也比较简单：

$post = new App\Post;
$post->title = '测试文章标题';
$post->content = '测试文章内容';
$post->user_id = 1;
$post->save();
创建时间和更新时间字段由 Eloquent 底层自动帮我们维护（遵循默认约定的话）。执行上面的代码就会在数据库新增一条记录（我们在 Tinker 中执行上述代码）：



我们先要创建一个新的 Post 模型实例，然后依次设置需要设置的字段，最后调用 save 方法保存即可。

此外，Eloquent 还为我们提供了一些快捷的插入方法，比如 firstOrCreate 和 firstOrNew，这两个方法都会先尝试通过指定查询条件在数据库中查找对应记录，如果没有找到的话，会创建对应模型类的实例，并将查询条件作为对应字段值设置到模型属性上。两者的区别是 firstOrCreate 方法在设置完模型属性后会将该模型记录保存到数据库中，而 firstOrNew 不会：

$post_1 = Post::firstOrCreate([
    'title' => '测试文章标题1',
    'user_id' => 1,
]);

$post_2 = Post::firstOrNew([
    'title' => '测试文章标题1',
    'user_id' => 1,
]);
不过学院君倒不建议这么做，感觉还是分开写代码可读性更好一些，也方便自己去处理一些异常情况。

更新数据
通过模型类更新数据表记录也很简单：

$post = Post::find(31);
$post->title = '测试文章标题更新';
$post->save();
更新时间 Eloquent 底层会自动帮我们维护，执行上面的代码即可完成该 $post 模型对应数据表记录的更新：



同样，Eloquent 也为我们提供了快捷的更新方法 updateOrCreate，该方法首先会根据传入参数对模型对应记录进行更新，如果发现对应记录不存在，则会将更新数据作为初始数据插入数据库，并保存（同样也不建议这么做，除非你的场景特别适合）：

$user = user::updateOrCreate(
    ['name' => '学院君'],
    ['email' => 'admin@laravelacademy.org']
);
有的时候我们可能需要批量更新模型对应数据表的多条记录，这可以借助查询构建器来实现：

Post::where('views', '>', 0)->update(['views' => 100]);
删除数据
通过模型类删除对应数据表记录和更新记录类似，都要先获取对应操作模型实例，删除对应记录更简单，获取到模型实例后，直接调用其删除方法即可：

$post = Post::find(31);
$post->delete();
这样，就完成了 id = 31 对应数据表记录的删除，你还可以通过 Eloquent 提供的 destroy 方法一次删除多条记录，通过数组传递多个主键 ID 即可：

Post::destroy([1,2,3]);
当然，你也可以通过查询构建器的方式删除指定记录：

$user = User::where('name', '学院君')->fisrt();
$user->delete();
结语
在这篇教程中，我们简单给大家介绍了 Eloquent 是什么，以及「约定优于配置」理念在 Eloquent 中的应用，最后还给大家演示了如何通过 Eloquent 实现数据库的增删改查，当然，Eloquent 的功能远不仅如此，还支持很多强大的功能，比如批量赋值、软删除、查询作用域设置、模型事件、关联关系等，下一篇教程开始学院君将带领大家来逐一了解这些高阶功能。

 @H_301_1@

今天关于laravel - 使用查询构造器进行数据的增删改查和laravel查询数据库的介绍到此结束，谢谢您的阅读，有关flask实现简单数据的增删改查（蓝图）、Laravel - 使用查询构造器查询、laravel - 查询构造器、laravel orm进行增删改查等更多相关知识的信息可以在本站进行查询。

本文标签：

上一篇Laravel基础课 使用查询构造器更新数据（laravel查询数据库）

下一篇laravel carbon 统计七天数据

相关文章