有时候我们难免会遇到一些查询出来的数据需要判空的操作,，但是我发觉一个问题，

就是查询出来的结果比如$result直接判空是解决不了的，而且他一直有东西，和tp框架有一些区别，那么我们该肿么办，下面是解决方法，不多写，看明白就好。

if ($result->first()) { } 
if (!$result->isEmpty()) { }
if ($result->count()) { }
//另外知得我们注意的是$result->count()当你写接口时用到分页的时候，可以直接把这个返回到分页，
不用在写一遍查询，也许你用到的时候能明白我写是啥

//1.mysql用户
//字段keywords的格式是1,2,3,4,5,6
select * from 表 where find_in_set('$key',keywords)
//2.PostgreSQL用户
//如果你数据库PostgreSQL或者其他的你可以用下面的方法代替查询，
但是得注意的是字段keywords的格式是,1,2,3,4,5,6,(也就是说前后都加逗号)
select * from 表 where position(',$key,' in keywords) >0
select A from 表 where position(A::TEXT in '".$code."') = 1 
or position('".$code."' in A::TEXT) = 1 
//3.Oracle用户
CREATE OR REPLACE  
FUNCTION FIND_IN_SET(piv_str1 varchar2, piv_str2 varchar2, p_sep varchar2 := ',')    
RETURN NUMBER IS      
  l_idx    number:=0; -- 用于计算piv_str2中分隔符的位置  
  str      varchar2(500);  -- 根据分隔符截取的子字符串  
  piv_str  varchar2(500) := piv_str2; -- 将piv_str2赋值给piv_str  
  res      number:=0; -- 返回结果  
  loopIndex number:=0;
BEGIN  
-- 如果piv_str中没有分割符，直接判断piv_str1和piv_str是否相等，相等 res=1  
IF instr(piv_str, p_sep, 1) = 0 THEN  
   IF piv_str = piv_str1 THEN   
      res:= 1;  
   END IF;  
ELSE  
-- 循环按分隔符截取piv_str  
LOOP  
    l_idx := instr(piv_str,p_sep);  
     loopIndex:=loopIndex+1;
-- 当piv_str中还有分隔符时  
      IF l_idx > 0 THEN  
       
   -- 截取第一个分隔符前的字段str  
         str:= substr(piv_str,1,l_idx-1);  
   -- 判断 str 和piv_str1 是否相等，相等 res=1 并结束循环判断  
         IF str = piv_str1 THEN   
           res:= loopIndex;  
           EXIT;  
         END IF;  
        piv_str := substr(piv_str,l_idx+length(p_sep));  
      ELSE  
   -- 当截取后的piv_str 中不存在分割符时，判断piv_str和piv_str1是否相等，相等 res=1  
        IF piv_str = piv_str1 THEN   
           res:= loopIndex;  
        END IF;  
        -- 无论最后是否相等，都跳出循环  
        EXIT;  
      END IF;  
END LOOP;  
-- 结束循环  
END IF;  
-- 返回res  
RETURN res;  
END FIND_IN_SET;

//1.1 insert ,insert方法接受两个参数 第一个参数呢 就是原生的SQL语句，第二个参数是一个数组 
对应的sql语句中的
    public function getInsert()
    {
        DB::insert('INSERT INTO articles (title, body)VALUE(?, ?)', 
        ['learn laravel', 'balablalabalabla']);
    }

//1.2 select ,我们的占位符不仅仅是? 也可以用":name" 来表示，对应的数组就是一对儿一对儿的键值。

    public function getArticles(){
        $articles = DB::select('SELECT * FROM articles WHERE title=:title', 
        ['title' => 'learn laravel']);
        foreach ($articles as $article){
            echo "$article->id";
            echo "$article->title";
            echo "$article->body";
        }
    }

//1.3 update ,update方法还返回了一个affected 这是受到影响的总行数。
    public function getUpdate()
    {
        $affected = DB::update('UPDATE articles SET title=:title,body=:body 
        WHERE id=:id',['title' => 'laravel database', 'body' => 'balabala',
         'id' => 1]);
        echo $affected;
    }

//1.4 delete
    public function getDelete()
    {
        $affected = DB::delete('DELETE FROM articles WHERE id=:id', 
        ['id' => 2]);
        echo $affected;
    }

//1.5 statement
    public function getDrop()
    {
        DB::statement('DROP TABLE articles');
    }

$roles = DB::table('表')->where('id',1)->select('pid')->get()->toArray()
$tables = DB::select("select * from pg_tables where schemaname='public'");
$object =  json_decode(json_encode($tables),true);

把查询出来的数组用foreach便利一下
foreach ($查出来的数组 as $vv){
            $另外的数组[] = $vv->id;
        }
        return $另外的数组；

//有时候我们遇到这种问题，就是两个where一个条件和（where和orwhere）
这个问题我们解决方法如下，当然原生sql肯定可以解决的，但是下面是集合的方法
DB::table('表')
->where('id',$input['id'])
->select(DB::raw('where A='.$uid.' or B='.$uid))
->select('id','smsid','replayid')
->orderBy('replaytime','desc')
->get();
//其他常规的就不列出了
$sql = "select id,username FROM 表 where aid=".$input['id']." 
and isdel=1 and (A=1 or b=2 or c=3)";

$userjob = DB::table('表1 as a')
    ->leftJoin('表2 as b', function ($join) {
        $join->on('表1.userjob', '=', '表2.code');
    })
    ->select(DB::raw('DISTINCT 表1.userjob,b.name'))
    ->get();

$data = DB::table('表')
        ->groupBy('userjob')
        ->select('userjob',DB::raw('count(userjob) as count'))
        ->get();

$data = DB::table('表1 as c')
    ->leftJoin('表2 as a', function ($join) {
        $join->on('表2.aid', '=', '表1.shortcode');
    })
    ->groupBy('表1.grade')
    ->select('表1.grade',DB::raw('count(表1.grade) as count'))
    ->get();

     //$data是结果集
foreach ($data as $v){
    //查询想要的结果
    $gradename = $this->getMessage($v->grade,'igrade');//usernjob名称
    $data1[]=[
        'userjob'=>$v->grade,
        'userjobname'=>$gradename,
        'count'=>$v->count
    ];
}

//字段在数组中
$users = DB::table('users')
            ->whereIn('id', [1, 2, 3])
            ->get();
//字段不在数组中
$users = DB::table('users')
        ->whereNotIn('id', [1, 2, 3])
        ->get();
//字符串在字段中
//$reader是字符串
$users = DB::table('users')
        ->whereRaw("position(',$reader,' in a.reader) >0")
        ->get();
//字符串不在字段中
//$reader是字符串
$users = DB::table('users')
        ->whereRaw("position(',$reader,' in a.reader) < 0")
        ->get();

$roles = DB::table('roles')->pluck('title', 'name');
foreach ($roles as $name => $title) {
    echo $title;
}
//循环遍历即可拿到对应的结果
$roles = DB::table('roles')->pluck('title');
//数组返回

$roles = DB::table('roles')->value('title');

$roles = DB::table('roles')->first('title');

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

//如果你需要操作数千条数据库记录，可以考虑使用 chunk 方法。
这个方法每次只取出一小块结果传递给 闭包 处理，
这对于编写数千条记录的 Artisan 命令 而言是非常有用的。例如，
一次处理整个 users 表中的 100 个记录：
DB::table('users')->orderBy('id')->chunk(100, function ($users) {
    foreach ($users as $user) {
        //
    }
});
你可以从 闭包 中返回 false 来阻止进一步的分块的处理：

DB::table('users')->orderBy('id')->chunk(100, function ($users) {
    // Process the records...

    return false;
});

//查询构造器还提供了将两个查询「合并」起来的快捷方式。例如，
你可以先创建一个初始查询，并使用 union 方法将它与第二个查询进行合并：

$first = DB::table('users')
            ->whereNull('first_name');

$users = DB::table('users')
            ->whereNull('last_name')
            ->union($first)
            ->get();
//用于多表子查询

Inner Join 语句
查询构造器也可以编写 join 语句。若要执行基本的「内连接」，你可以在查询构造器实例上使用 
join 方法。传递给 join 方法的第一个参数是你要需要连接的表的名称，
而其它参数则用来指定连接的字段约束。你还可以在单个查询中连接多个数据表：

$users = DB::table('users')
            ->join('contacts', 'users.id', '=', 'contacts.user_id')
            ->join('orders', 'users.id', '=', 'orders.user_id')
            ->select('users.*', 'contacts.phone', 'orders.price')
            ->get();
Left Join 语句
如果你想用「左连接」来代替「内连接」，请使用 leftJoin 方法。leftJoin 方法的用法和
join 方法一样：

$users = DB::table('users')
            ->leftJoin('posts', 'users.id', '=', 'posts.user_id')
            ->get();
Cross Join 语句
使用 crossJoin 方法和你想要交叉连接的表名来做「交叉连接」。交叉连接在第一个表和连接之间生成笛卡尔积

$users = DB::table('sizes')
            ->crossJoin('colours')
            ->get();
高级 Join 语句
你也可以指定更高级的 join 语句。比如传递一个 闭包 作为 join 方法的第二个参数。
此 闭包 接收一个 JoinClause 对象，从而在其中指定 join 语句中指定约束：

DB::table('users')
        ->join('contacts', function ($join) {
            $join->on('users.id', '=', 'contacts.user_id')->orOn(...);
        })
        ->get();
如果你想要在连接上使用「where」风格的语句，可以在连接上使用 where 和 orWhere 方法。
这些方法可以用来比较值和对应的字段：

DB::table('users')
        ->join('contacts', function ($join) {
            $join->on('users.id', '=', 'contacts.user_id')
                 ->where('contacts.user_id', '>', 5);
        })
        ->get();

    //传普通值  
$users = DB::table('users')
            ->where('name', 'like', 'T%')
            ->get();
    //传数组
$users = DB::table('users')->where([
    ['status', '=', '1'],
    ['subscribed', '<>', '1'],
])->get();

whereBetween

whereBetween 方法用来验证字段的值介于两个值之间：

$users = DB::table('users')
                    ->whereBetween('votes', [1, 100])->get();
whereNotBetween

whereNotBetween 方法验证字段的值不在两个值之间：

$users = DB::table('users')
                    ->whereNotBetween('votes', [1, 100])
                    ->get();
whereIn / whereNotIn

whereIn 方法验证字段的值在指定的数组内：

$users = DB::table('users')
                    ->whereIn('id', [1, 2, 3])
                    ->get();
whereNotIn 方法验证字段的值不在指定的数组内：

$users = DB::table('users')
                    ->whereNotIn('id', [1, 2, 3])
                    ->get();
whereNull / whereNotNull

whereNull 方法验证字段的值为 NULL：

$users = DB::table('users')
                    ->whereNull('updated_at')
                    ->get();
whereNotNull 方法验证字段的值不为 NULL：

$users = DB::table('users')
                    ->whereNotNull('updated_at')
                    ->get();
whereDate / whereMonth / whereDay / whereYear / whereTime

whereDate 方法用于比较字段的值和日期：

$users = DB::table('users')
                ->whereDate('created_at', '2016-12-31')
                ->get();
whereMonth 方法用于比较字段的值与一年的特定月份：

$users = DB::table('users')
                ->whereMonth('created_at', '12')
                ->get();
whereDay 方法用于比较字段的值与特定的一个月的某一天：

$users = DB::table('users')
                ->whereDay('created_at', '31')
                ->get();
whereYear 方法用于比较字段的值与特定年份：

$users = DB::table('users')
                ->whereYear('created_at', '2016')
                ->get();
whereTime 方法用于比较字段的值与特定的时间：

$users = DB::table('users')
                ->whereTime('created_at', '=', '11:20')
                ->get();
whereColumn

whereColumn 方法用于验证两个字段是否相等：

$users = DB::table('users')
                ->whereColumn('first_name', 'last_name')
                ->get();
还可以将比较运算符传递给该方法：

$users = DB::table('users')
                ->whereColumn('updated_at', '>', 'created_at')
                ->get();
whereColumn 方法也可以传递一个包含多个条件的数组。这些条件将使用 and 运算符进行连接：

$users = DB::table('users')
                ->whereColumn([
                    ['first_name', '=', 'last_name'],
                    ['updated_at', '>', 'created_at']
                ])->get();

$users = DB::table('users')
        ->whereColumn('updated_at', '>', 'created_at')
        ->get();

whereColumn 方法也可以传递一个包含多个条件的数组。这些条件将使用 and 运算符进行连接：
$users = DB::table('users')
    ->whereColumn([
        ['first_name', '=', 'last_name'],
        ['updated_at', '>', 'created_at']
    ])->get();

DB::table('users')
            ->where('name', '=', 'John')
            ->orWhere(function ($query) {
                $query->where('votes', '>', 100)
                      ->where('title', '<>', 'Admin');
            })
            ->get();
在上面例子中将 闭包 传递到 orWhere 方法中，指示查询构造器开始一个约束分组。此 闭包 
接收一个查询构造器实例，你可以用它来设置应包含在括号组中的约束。上面的例子会产生下面的 SQL：

select * from users where name = 'John' or (votes > 100 and title <> 'Admin')

Where Exists 语句
whereExists 方法允许你编写 where exists SQL 语句。此方法接受一个 闭包 参数，
此闭包要接收一个查询构造器实例，让你可以定义放在「exists」语句中的查询：

DB::table('users')
            ->whereExists(function ($query) {
                $query->select(DB::raw(1))
                      ->from('orders')
                      ->whereRaw('orders.user_id = users.id');
            })
            ->get();
上述的查询将生成以下 SQL：

select * from users
where exists (
    select 1 from orders where orders.user_id = users.id
)

JSON where 语句
Laravel 也支持查询 JSON 类型的字段（仅在对 JSON 类型支持的数据库上）。
目前，本特性仅支持 MySQL 5.7+ 和 Postgres数据库。可以使用 -> 运算符来查询 JSON 列数据：

$users = DB::table('users')
                ->where('options->language', 'en')
                ->get();

$users = DB::table('users')
                ->where('preferences->dining->meal', 'salad')
                ->get();

有时你可能想要子句只适用于某个情况为真时才执行查询。例如，如果给定的输入值出现在传入请求中时，
你可能想要判断它能达成某个 where 语句，你可以使用 when 方法来完成此操作：

$role = $request->input('role');

$users = DB::table('users')
                ->when($role, function ($query) use ($role) {
                    return $query->where('role_id', $role);
                })
                ->get();
只有当 when 方法的第一个参数为 true 时，闭包里的 where 语句才会执行。
如果第一个参数是 false，这个闭包将不会被执行。

你可以将另一个闭包当作第三个参数传递给 when 方法。如果第一个参数的值为
 false 时，这个闭包将执行。为了说明如何使用此功能，我们将使用它配置查询的默认排序：

$sortBy = null;

$users = DB::table('users')
                ->when($sortBy, function ($query) use ($sortBy) {
                    return $query->orderBy($sortBy);
                }, function ($query) {
                    return $query->orderBy('name');
                })
                ->get();

    $aa = DB::table('XXXX as a')
    ->where('a.aa','=',$input['aa'])
    ->selectRaw('a.id::INT as A,a.B')
    //->selectRaw('a.id::TEXT as A,a.B')
    ->get();