데이터베이스 사용법(기반 Laravel 데이터베이스 구성 요소)

모든 행 가져오기

<?php
namespace app\controller;

use support\Request;
use support\Db;

class UserController
{
    public function all(Request $request)
    {
        $users = Db::table('users')->get();
        return view('user/all', ['users' => $users]);
    }
}

지정한 열 가져오기

$users = Db::table('user')->select('name', 'email as user_email')->get();

하나의 행 가져오기

$user = Db::table('users')->where('name', 'John')->first();

하나의 열 가져오기

$titles = Db::table('roles')->pluck('title');

지정한 id 필드 값을 인덱스로 사용

$roles = Db::table('roles')->pluck('title', 'id');

foreach ($roles as $id => $title) {
    echo $title;
}

단일 값(필드) 가져오기

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

중복 제거

$email = Db::table('user')->select('nickname')->distinct()->get();

청크 결과

수천 개의 데이터베이스 기록을 처리해야 하는 경우, 이러한 데이터를 한 번에 읽는 것은 시간이 많이 걸리며 메모리 초과를 초래할 수 있으므로, chunkById 메서드를 사용하는 것이 좋습니다. 이 메서드는 결과 집합의 작은 조각을 가져와서 이를 클로저 함수에 전달하여 처리합니다. 예를 들어, 모든 users 테이블 데이터는 한 번에 100개의 레코드를 처리하도록 나눌 수 있습니다:

Db::table('users')->orderBy('id')->chunkById(100, function ($users) {
    foreach ($users as $user) {
        //
    }
});

클로저에서 false를 반환하여 청크 결과의 계속 가져오기를 중지할 수 있습니다.

Db::table('users')->orderBy('id')->chunkById(100, function ($users) {
    // 레코드 처리...

    return false;
});

주의: 콜백 안에서 데이터를 삭제하지 마십시오. 그렇게 하면 일부 레코드가 결과 집합에 포함되지 않을 수 있습니다.

집계

쿼리 빌더는 count, max, min, avg, sum 등 다양한 집계 메서드를 제공합니다.

$users = Db::table('users')->count();
$price = Db::table('orders')->max('price');
$price = Db::table('orders')->where('finalized', 1)->avg('price');

기록 존재 여부 판단

return Db::table('orders')->where('finalized', 1)->exists();
return Db::table('orders')->where('finalized', 1)->doesntExist();

원시 표현식

원형

selectRaw($expression, $bindings = [])

때때로 쿼리에서 원시 표현식을 사용해야 할 수도 있습니다. selectRaw()를 사용하여 원시 표현식을 생성할 수 있습니다:

$orders = Db::table('orders')
                ->selectRaw('price * ? as price_with_tax', [1.0825])
                ->get();

동일하게 whereRaw(), orWhereRaw(), havingRaw(), orHavingRaw(), orderByRaw(), groupByRaw()와 같은 원시 표현식 메서드도 제공됩니다.

Db::raw($value)는 원시 표현식을 생성하는 데 사용되지만 매개변수 바인딩 기능이 없으므로 SQL 인젝션 문제에 주의해야 합니다.

$orders = Db::table('orders')
                ->select('department', Db::raw('SUM(price) as total_sales'))
                ->groupBy('department')
                ->havingRaw('SUM(price) > ?', [2500])
                ->get();

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

// leftJoin            
$users = Db::table('users')
            ->leftJoin('posts', 'users.id', '=', 'posts.user_id')
            ->get();

// rightJoin
$users = Db::table('users')
            ->rightJoin('posts', 'users.id', '=', 'posts.user_id')
            ->get();

// crossJoin    
$users = Db::table('sizes')
            ->crossJoin('colors')
            ->get();

Union 문

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

$users = Db::table('users')
            ->whereNull('last_name')
            ->union($first)
            ->get();

Where 문

원형

where($column, $operator = null, $value = null)

첫 번째 매개변수는 열 이름이고, 두 번째 매개변수는 데이터베이스 시스템에서 지원하는 아무 연산자이며, 세 번째는 해당 열과 비교할 값입니다.

$users = Db::table('users')->where('votes', '=', 100)->get();

// 연산자가 같을 경우 생략 가능하므로 이 표현식은 위의와 같습니다
$users = Db::table('users')->where('votes', 100)->get();

$users = Db::table('users')
                ->where('votes', '>=', 100)
                ->get();

$users = Db::table('users')
                ->where('votes', '<>', 100)
                ->get();

$users = Db::table('users')
                ->where('name', 'like', 'T%')
                ->get();

또한 조건 배열을 where 함수에 전달할 수 있습니다:

$users = Db::table('users')->where([
    ['status', '=', '1'],
    ['subscribed', '<>', '1'],
])->get();

orWhere 메서드는 where 메서드와 같은 매개변수를 받습니다:

$users = Db::table('users')
                    ->where('votes', '>', 100)
                    ->orWhere('name', 'John')
                    ->get();

orWhere 메서드에 클로저를 첫 번째 매개변수로 전달할 수 있습니다:

// SQL: select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
$users = Db::table('users')
            ->where('votes', '>', 100)
            ->orWhere(function($query) {
                $query->where('name', 'Abigail')
                      ->where('votes', '>', 50);
            })
            ->get();

whereBetween / orWhereBetween 메서드는 필드 값이 주어진 두 값 사이에 있는지 검증합니다:

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

whereNotBetween / orWhereNotBetween 메서드는 필드 값이 주어진 두 값 밖에 있는지 검증합니다:

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

whereIn / whereNotIn / orWhereIn / orWhereNotIn 메서드는 필드 값이 지정된 배열에 반드시 존재해야 함을 검증합니다:

$users = Db::table('users')
                    ->whereIn('id', [1, 2, 3])
                    ->get();

whereNull / whereNotNull / orWhereNull / orWhereNotNull 메서드는 지정된 필드가 NULL이어야 함을 검증합니다:

$users = Db::table('users')
                    ->whereNull('updated_at')
                    ->get();

whereNotNull 메서드는 지정된 필드가 NULL이 아닌지 검증합니다:

$users = Db::table('users')
                    ->whereNotNull('updated_at')
                    ->get();

whereDate / whereMonth / whereDay / whereYear / whereTime 메서드는 필드 값과 주어진 날짜를 비교하는 데 사용됩니다:

$users = Db::table('users')
                ->whereDate('created_at', '2016-12-31')
                ->get();

whereColumn / orWhereColumn 메서드는 두 필드의 값이 같은지 비교하는 데 사용됩니다:

$users = Db::table('users')
                ->whereColumn('first_name', 'last_name')
                ->get();

// 비교 연산자를 전송할 수도 있습니다
$users = Db::table('users')
                ->whereColumn('updated_at', '>', 'created_at')
                ->get();

// whereColumn 메서드는 배열을 전달할 수도 있습니다
$users = Db::table('users')
                ->whereColumn([
                    ['first_name', '=', 'last_name'],
                    ['updated_at', '>', 'created_at'],
                ])->get();

매개변수 그룹화

// select * from users where name = 'John' and (votes > 100 or title = 'Admin')
$users = Db::table('users')
           ->where('name', '=', 'John')
           ->where(function ($query) {
               $query->where('votes', '>', 100)
                     ->orWhere('title', '=', 'Admin');
           })
           ->get();

whereExists

// select * from users where exists ( select 1 from orders where orders.user_id = users.id )
$users = Db::table('users')
           ->whereExists(function ($query) {
               $query->select(Db::raw(1))
                     ->from('orders')
                     ->whereRaw('orders.user_id = users.id');
           })
           ->get();

orderBy

$users = Db::table('users')
                ->orderBy('name', 'desc')
                ->get();

무작위 정렬

$randomUser = Db::table('users')
                ->inRandomOrder()
                ->first();

무작위 정렬은 서버 성능에 큰 영향을 미치므로 사용하는 것을 권장하지 않습니다.

groupBy / having

$users = Db::table('users')
                ->groupBy('account_id')
                ->having('account_id', '>', 100)
                ->get();
// groupBy 메서드는 여러 매개변수를 받을 수 있습니다
$users = Db::table('users')
                ->groupBy('first_name', 'status')
                ->having('account_id', '>', 100)
                ->get();

offset / limit

$users = Db::table('users')
                ->offset(10)
                ->limit(5)
                ->get();

삽입

단일 삽입

Db::table('users')->insert(
    ['email' => 'john@example.com', 'votes' => 0]
);

다중 삽입

Db::table('users')->insert([
    ['email' => 'taylor@example.com', 'votes' => 0],
    ['email' => 'dayle@example.com', 'votes' => 0]
]);

자동 증가 ID

$id = Db::table('users')->insertGetId(
    ['email' => 'john@example.com', 'votes' => 0]
);

주의: PostgreSQL을 사용할 때, insertGetId 메서드는 기본적으로 id를 자동 증가 필드 이름으로 사용합니다. 다른 "시퀀스"에서 ID를 가져오려면 insertGetId 메서드에 필드 이름을 두 번째 매개변수로 전달하면 됩니다.

업데이트

$affected = Db::table('users')
              ->where('id', 1)
              ->update(['votes' => 1]);

업데이트 또는 삽입

때때로 데이터베이스에서 기존 기록을 업데이트하거나 일치하는 기록이 없으면 생성하려고 할 수 있습니다:

Db::table('users')
    ->updateOrInsert(
        ['email' => 'john@example.com', 'name' => 'John'],
        ['votes' => '2']
    );

updateOrInsert 메서드는 먼저 첫 번째 매개변수의 키 및 값 쌍을 사용하여 일치하는 데이터베이스 기록을 찾으려고 시도합니다. 기록이 존재하면 두 번째 매개변수의 값을 사용하여 기록을 업데이트합니다. 기록을 찾을 수 없으면 새로운 기록이 삽입되며, 새로운 기록의 데이터는 두 배열의 조합입니다.

자동 증가 & 자동 감소

이 두 방법은 최소한 하나의 매개변수를 받습니다: 수정할 열입니다. 두 번째 매개변수는 열의 증가 또는 감소 양을 제어하는 데 사용할 수 있는 선택적입니다:

Db::table('users')->increment('votes');

Db::table('users')->increment('votes', 5);

Db::table('users')->decrement('votes');

Db::table('users')->decrement('votes', 5);

작업 중에 수정할 필드를 지정할 수도 있습니다:

Db::table('users')->increment('votes', 1, ['name' => 'John']);

삭제

Db::table('users')->delete();

Db::table('users')->where('votes', '>', 100)->delete();

테이블을 비워야 하는 경우, truncate 메서드를 사용하여 모든 행을 삭제하고 자동 증가 ID를 0으로 재설정할 수 있습니다:

Db::table('users')->truncate();

트랜잭션

참조 데이터베이스 트랜잭션

비관적 잠금

쿼리 빌더에는 select 구문에서 "비관적 잠금"을 구현하는 데 도움이 되는 몇 가지 함수가 포함되어 있습니다. 쿼리에서 "공유 잠금"을 구현하려면 sharedLock 메서드를 사용하면 됩니다. 공유 잠금은 선택한 데이터 열이 트랜잭션이 커밋될 때까지 변조되는 것을 방지합니다:

Db::table('users')->where('votes', '>', 100)->sharedLock()->get();

또는 lockForUpdate 메서드를 사용할 수 있습니다. "업데이트" 잠금을 사용하면 행이 다른 공유 잠금에 의해 수정되거나 선택되는 것을 방지할 수 있습니다:

Db::table('users')->where('votes', '>', 100)->lockForUpdate()->get();

디버깅

쿼리 결과나 SQL 문을 출력하려면 dd 또는 dump 메서드를 사용할 수 있습니다. dd 메서드는 디버그 정보를 표시한 후 요청을 중지합니다. dump 메서드는 디버그 정보를 표시하지만 요청을 중지하지 않습니다:

Db::table('users')->where('votes', '>', 100)->dd();
Db::table('users')->where('votes', '>', 100)->dump();

주의
디버깅하려면 symfony/var-dumper를 설치해야 하며, 명령어는 composer require symfony/var-dumper입니다.