18 Tips To Optimize Your Laravel Database Queries #terjemah

Tips untuk mengoptimasi queri database aplikasi Laravel milikmu

Assalamu’alaikum Warahmatullahi Wabarakatuh…

Jika aplikasi Anda berjalan lambat atau membuat banyak queri database, ikuti tip pengoptimalan kinerja di bawah ini untuk meningkatkan waktu loading aplikasi Anda.

1. Mengambil Kumpulan Dataset Besar

Tip ini berfokus pada peningkatan penggunaan memori aplikasi Anda ketika berhadapan dengan kumpulan dataset besar. Jika aplikasi Anda perlu memproses kumpulan set yang besar, daripada mengambil semuanya sekaligus, Anda dapat mengambil sebagian dari hasil dan memprosesnya dalam beberapa kelompok.

Untuk mengambil banyak hasil dari tabel yang disebut posts kita biasanya melakukan seperti di bawah ini.

$posts = Post::all(); // when using eloquent
$posts = DB::table('posts')->get(); // when using query builder
foreach ($posts as $post){
 // Process posts
}

Contoh di atas akan mengambil semua record dari tabel posts dan memprosesnya. Bagaimana jika tabel ini memiliki 1 juta baris? Kita akan cepat kehabisan memori.

Untuk menghindari masalah saat menangani kumpulan data besar, kita dapat mengambil sebagian hasil dan memprosesnya seperti di bawah ini.

Opsi 1: Menggunakan chunk

// when using eloquent
$posts = Post::chunk(100, function($posts){
    foreach ($posts as $post){
     // Process posts
    }
});
// when using query builder
$posts = DB::table('posts')->chunk(100, function ($posts){
    foreach ($posts as $post){
     // Process posts
    }
});

Contoh di atas mengambil 100 record dari tabel posts, lalu memprosesnya, kemudian mengambil 100 record lainnya, dan memprosesnya. Iterasi (perulangan) ini akan terus berlanjut sampai semua record diproses.

Pendekatan ini akan membuat lebih banyak kueri basis data tetapi lebih hemat memori. Biasanya, pemrosesan kumpulan dataset besar akan selesai di latar belakang. Jadi boleh saja membuat lebih banyak kueri saat berjalan di latar belakang untuk menghindari kehabisan memori saat memproses kumpulan dataset besar.

Opsi 2: Menggunakan cursor

// when using eloquent
foreach (Post::cursor() as $post){
   // Process a single post
}
// when using query builder
foreach (DB::table('posts')->cursor() as $post){
   // Process a single post
}

Contoh di atas akan membuat query database tunggal, mengambil semua record dari tabel, dan menghidrasi model Eloquent satu per satu. Pendekatan ini hanya akan membuat satu query database untuk mengambil semua posting. Tetapi menggunakan generator php untuk mengoptimalkan penggunaan memori.

kapan kita bisa menggunakan cara ini?

Meskipun ini sangat mengoptimalkan penggunaan memori pada tingkat aplikasi, Karena kita mengambil semua entri dari tabel, penggunaan memori pada instance database masih akan lebih tinggi.

Lebih baik menggunakan cursor() Jika aplikasi web yang menjalankan aplikasi Anda memiliki lebih sedikit memori, dan instance database memiliki lebih banyak memori. Namun, jika instance database Anda tidak memiliki cukup memori, lebih baik tetap menggunakan chunk().

opsi 3: Menggunakan chunkById

// when using eloquent
$posts = Post::chunkById(100, function($posts){
    foreach ($posts as $post){
     // Process posts
    }
});
// when using query builder
$posts = DB::table('posts')->chunkById(100, function ($posts){
    foreach ($posts as $post){
     // Process posts
    }
});

Perbedaan utama antara chunk() dan chunkById() adalah bahwa chunk() mengambil berdasarkan offset dan limit. Sedangkan chunkById() mengambil hasil database berdasarkan kolom id. Kolom id ini biasanya berupa tipe integer (angka), dan dalam kebanyakan kasus, kolom ini akan bertambah secara otomatis (auto-increment).

Kueri yang dibuat oleh chunk() dan chunkById() adalah sebagai berikut.

chunk()

select * from posts offset 0 limit 100
select * from posts offset 101 limit 100

chunkById()

select * from posts order by id asc limit 100
select * from posts where id > 100 order by id asc limit 100

Umumnya, menggunakan limit dan offset lebih lambat, dan kita harus mencoba menghindari menggunakannya. Artikel ini menjelaskan secara rinci masalah penggunaan offset.

Karena chunkById() menggunakan kolom id yang merupakan integer (angka), dan queri menggunakan klausa where, queri akan jauh lebih cepat.

Kapan Anda bisa menggunakan chunkById?

Jika tabel database Anda memiliki kolom-kolom primary-key, yang merupakan kolom auto-increment.

2. Pilihlah hanya kolom yang dibutuhkan

Biasanya untuk mengambil hasil dari tabel database, kita akan melakukan hal berikut.

$posts = Post::find(1); //When using eloquent
$posts = DB::table('posts')->where('id','=',1)->first(); //When using query builder

Kode di atas akan menghasilkan kueri seperti di bawah ini.

select * from posts where id = 1 limit 1

Seperti yang Anda lihat, kueri melakukan pemilihan select *. Ini berarti mengambil semua kolom dari tabel database. Ini bagus jika kita benar-benar membutuhkan semua kolom dari tabel.

Sebagai gantinya, jika kita hanya membutuhkan kolom tertentu (id, judul), kita hanya dapat mengambil kolom tersebut seperti di bawah ini.

$posts = Post::select(['id','title'])->find(1); //When using eloquent
2$posts = DB::table('posts')->where('id','=',1)->select(['id','title'])->first(); //When using query builder

Kode di atas akan menghasilkan kueri seperti di bawah ini:

select id,title from posts where id = 1 limit 1

3. Gunakan pluck jika Anda hanya membutuhkan satu atau dua kolom dari database

Tip ini lebih berfokus pada waktu yang dihabiskan setelah hasil diambil dari database. Ini tidak mempengaruhi waktu kueri yang sebenarnya.

Seperti yang saya sebutkan di atas, untuk mengambil kolom tertentu, kami akan melakukannya seperti ini:

$posts = Post::select(['title','slug'])->get(); //When using eloquent
2$posts = DB::table('posts')->select(['title','slug'])->get(); //When using query builder

Ketika kode di atas dijalankan, ia melakukan hal berikut di belakang layar.

• Menjalankan queri select title, slug from posts di database
• Membuat object baru dari model Post untuk setiap baris yang didapatkan (Untuk Queri builder, itu akan membuat object PHP standar)
• Membuat Collection baru dengan menggunakan model Post
• Mengembalikan Collection nya.

Sekarang, untuk mengakses hasilnya, kita akan melakukan:

foreach ($posts as $post){
    // $post is a Post model or php standard object
    $post->title;
    $post->slug;
}

Pendekatan di atas memiliki overhead tambahan yang menyebabkan hydrating pada model Post untuk setiap baris dan membuat collection untuk object ini. Ini akan lebih baik jika Anda benar-benar membutuhkan contoh model Post daripada datanya.

Tetapi jika yang Anda butuhkan hanyalah dua nilai itu, Anda dapat melakukan hal berikut.

$posts = Post::pluck('title', 'slug'); //When using eloquent
$posts = DB::table('posts')->pluck('title','slug'); //When using query builder

Ketika kode di atas dijalankan, ia melakukan hal berikut di belakang layar.

• Menjalankan select title, slug from posts di database.
• Membuat sebuah array dimana, title sebagai array value nya dan slug sebagai array key nya.
• Mengembalikan array dengan format seperti ini:

[ 
   slug => title,
   slug => title,
]

Sekarang, untuk mengakses hasilnya, kita bisa melakukannya seperti ini:

foreach ($posts as $slug => $title){
    // $title is the title of a post
    // $slug is the slug of a post
}

Jika Anda ingin mengambil hanya satu kolom, Anda dapat melakukan ini:

$posts = Post::pluck('title'); //When using eloquent
$posts = DB::table('posts')->pluck('title'); //When using query builder
foreach ($posts as  $title){
    // $title is the title of a post
}

Pendekatan di atas menghilangkan pembuatan object Post untuk setiap baris. Sehingga mengurangi penggunaan memori dan waktu yang dihabiskan untuk memproses hasil kueri.

Saya merekomendasikan menggunakan pendekatan di atas hanya pada kode baru. Saya pribadi merasa akan kembali dan melakukan refactor kode, jika Anda mengikuti tip di atas tidak sepadan dengan waktu yang dihabiskan untuk melakukan itu. Memfaktorkan ulang kode yang ada hanya jika kode Anda diproses dalam jumlah besar kumpulan data atau jika Anda memiliki waktu luang.

4. Menghitung baris menggunakan queri daripada collection

Untuk menghitung jumlah total baris dalam sebuah tabel, biasanya yang kita lakukan adalah

$posts = Post::all()->count(); //When using eloquent
$posts = DB::table('posts')->get()->count(); //When using query builder

Ini akan menghasilkan queri berikut:

select * from posts

Pendekatan di atas akan mengambil semua baris dari tabel, memuatnya ke dalam object collection, dan menghitung hasilnya. Ini berjalan dengan baik ketika ada sedikit baris dalam tabel database. Tapi kita akan cepat kehabisan memori seiring bertambahnya tabel di database.

Daripada menggunakan pendekatan di atas, kita dapat langsung menghitung jumlah total baris pada database itu sendiri.

$posts = Post::count(); //When using eloquent
$posts = DB::table('posts')->count(); //When using query builder

Ini akan menghasilkan kueri berikut:

select count(*) from posts

Menghitung baris dalam sql adalah proses yang lambat dan berkinerja buruk ketika tabel database memiliki begitu banyak baris. Lebih baik menghindari penghitungan baris sebanyak mungkin.

5. Menghindari penggunaan queri N+1 dengan cara eager loading relationship

Anda mungkin pernah mendengar tip ini jutaan kali. Jadi saya akan membuatnya sesingkat dan sesederhana mungkin. Mari kita asumsikan Anda memiliki skenario berikut:

class PostController extends Controller
{
    public function index()
    {
        $posts = Post::all();
        return view('posts.index', ['posts' => $posts ]);
    }
}

dengan file posts/index.blade.php

@foreach($posts as $post)
    <li>
        <h3>{{ $post->title }}</h3>
        <p>Author: {{ $post->author->name }}</p>
    </li>
@endforeach

Kode di atas mengambil semua post dan menampilkan post title dan authornya di halaman web, dan itu mengasumsikan Anda memiliki hubungan penulis pada model posting Anda.

Menjalankan kode di atas akan menghasilkan menjalankan kueri berikut.

select * from posts // Assume this query returned 5 posts
select * from authors where id = { post1.author_id }
select * from authors where id = { post2.author_id }
select * from authors where id = { post3.author_id }
select * from authors where id = { post4.author_id }
select * from authors where id = { post5.author_id }

Seperti yang Anda lihat, kami memiliki satu kueri untuk mengambil post, dan 5 kueri untuk mengambil author (Karena kami berasumsi kami memiliki 5 post.) Jadi untuk setiap post yang diambil, itu membuat satu kueri terpisah untuk mengambil authornya.

Jadi jika ada sebanyak N jumlah posting, itu akan membuat N+1 query( 1 query untuk mengambil posting dan N query untuk mengambil penulis untuk setiap posting). Ini umumnya dikenal sebagai masalah queri N+1.

Untuk menghindari hal tersebut, gunakan eager load untuk memuat hubungan author pada postingan seperti di bawah ini.

$posts = Post::all(); // Hindari melakukan ini
$posts = Post::with(['author'])->get(); // Tapi, lakukan ini

Menjalankan kode di atas akan menghasilkan menjalankan kueri berikut.

select * from posts // Assume this query returned 5 posts
select * from authors where id in( { post1.author_id }, { post2.author_id }, { post3.author_id }, { post4.author_id }, { post5.author_id } )

6. Menggunakan Eager load untuk nested relationship

Dari contoh di atas, anggap penulis milik tim, dan Anda ingin menampilkan nama tim juga. Jadi di file blade yang akan Anda lakukan seperti di bawah ini.

@foreach($posts as $post)
    <li>
        <h3>{{ $post->title }}</h3>
        <p>Author: {{ $post->author->name }}</p>
        <p>Author's Team: {{ $post->author->team->name }}</p>
    </li>
@endforeach

Sekarang lakukan seperti di bawah ini:

$posts = Post::with(['author'])->get();

Akan menghasilkan queri berikut:

select * from posts // Assume this query returned 5 posts
select * from authors where id in( { post1.author_id }, { post2.author_id }, { post3.author_id }, { post4.author_id }, { post5.author_id } )
select * from teams where id = { author1.team_id }
select * from teams where id = { author2.team_id }
select * from teams where id = { author3.team_id }
select * from teams where id = { author4.team_id }
select * from teams where id = { author5.team_id }

Seperti yang Anda lihat, meskipun kita melakukan eager loading relasi author, itu masih membuat lebih banyak queri. Karena kita tidak melakukan eager loading pada saat memuat relasi tim pada author.

Kita dapat memperbaikinya dengan melakukan hal berikut.

$posts = Post::with(['author.team'])->get();

Menjalankan kode di atas akan menghasilkan menjalankan kueri berikut.

select * from posts // Assume this query returned 5 posts
select * from authors where id in( { post1.author_id }, { post2.author_id }, { post3.author_id }, { post4.author_id }, { post5.author_id } )
select * from teams where id in( { author1.team_id }, { author2.team_id }, { author3.team_id }, { author4.team_id }, { author5.team_id } )

Dengan melakukan eager loading, kita mengurangi jumlah kueri dari 11 menjadi 3.

7. Jangan menggunakan relasi belongsTo relationship jika hanya membutuhkan id nya saja

Bayangkan Anda memiliki dua tabel post dan author. Tabel post memiliki kolom author_id yang mewakili milik hubungan di tabel author.

Untuk mendapatkan id author dari sebuah post, kita biasanya melakukan:

$post = Post::findOrFail(<post id>);
$post->author->id;

Ini akan menghasilkan dua kueri yang dieksekusi.

select * from posts where id = <post id> limit 1
select * from authors where id = <post author id> limit 1

Sebagai gantinya, Anda bisa langsung mendapatkan id penulis dengan melakukan hal berikut.

$post = Post::findOrFail(<post id>);
$post->author_id; // posts table has a column author_id which stores id of the author

Kapan kita bisa menggunakan pendekatan ini?

Anda dapat menggunakan pendekatan diatas ketika Anda yakin bahwa barisnya (data) selalu ada di tabel penulis jika direferensikan dari tabel posting.

8. Hindari queri yang tidak perlu

Seringkali, kami membuat kueri basis data yang tidak diperlukan.
Perhatikan contoh di bawah ini:

<?php
class PostController extends Controller
{
    public function index()
    {
        $posts = Post::all();
        $private_posts = PrivatePost::all();
        return view('posts.index', ['posts' => $posts, 'private_posts' => $private_posts ]);
   }
}

Kode di atas mengambil baris dari dua tabel yang berbeda (mis: post, private_posts) dan meneruskannya untuk dilihat. Tampilan file terlihat seperti di bawah ini.

// posts/index.blade.php
@if( request()->user()->isAdmin() )
    <h2>Private Posts</h2>
    <ul>
        @foreach($private_posts as $post)
            <li>
                <h3>{{ $post->title }}</h3>
                <p>Published At: {{ $post->published_at }}</p>
            </li>
        @endforeach
    </ul>
@endif

<h2>Posts</h2>
<ul>
    @foreach($posts as $post)
        <li>
            <h3>{{ $post->title }}</h3>
            <p>Published At: {{ $post->published_at }}</p>
        </li>
    @endforeach
</ul>

Seperti yang Anda lihat di atas, $private_posts hanya dapat dilihat oleh pengguna yang merupakan admin. Semua pengguna tidak dapat melihat posting ini.

Masalahnya di sini adalah, ketika kita melakukan ini:

$posts = Post::all();
$private_posts = PrivatePost::all();

Kita membuat dua queri. Satu untuk mendapatkan record dari tabel post dan satu lagi untuk mendapatkan record dari tabel private_posts.

Record dari tabel private_posts hanya dapat dilihat oleh pengguna admin. Tapi kita masih membuat queri untuk mengambil record ini untuk semua pengguna meskipun tidak terlihat.

Kita dapat memodifikasi logika kita di bawah ini untuk menghindari kueri tambahan ini.

$posts = Post::all();
$private_posts = collect();
if( request()->user()->isAdmin() ){
    $private_posts = PrivatePost::all();
}

Dengan mengubah logika kita di atas, kita membuat dua kueri untuk pengguna admin dan satu kueri untuk semua pengguna lain.

9. Gabungakan queri yang mirip

Terkadang kita perlu membuat kueri untuk mengambil berbagai jenis baris dari tabel yang sama.

$published_posts = Post::where('status','=','published')->get();
$featured_posts = Post::where('status','=','featured')->get();
$scheduled_posts = Post::where('status','=','scheduled')->get();

Kode di atas mengambil baris dengan status berbeda dari tabel yang sama. Kode akan menghasilkan queri berikut.

select * from posts where status = 'published'
select * from posts where status = 'featured'
select * from posts where status = 'scheduled'

Seperti yang Anda lihat, itu membuat tiga kueri berbeda ke tabel yang sama untuk mengambil record. Kita dapat melakukan refactor kode ini untuk membuat hanya satu kueri basis data.

$posts =  Post::whereIn('status',['published', 'featured', 'scheduled'])->get();
$published_posts = $posts->where('status','=','published');
$featured_posts = $posts->where('status','=','featured');
$scheduled_posts = $posts->where('status','=','scheduled');

Akan menghasilkan queri seperti berikut:

select * from posts where status in ( 'published', 'featured', 'scheduled' )

Kode di atas membuat satu queri untuk mengambil semua posting yang memiliki status tertentu dan membuat koleksi terpisah untuk setiap status dengan memfilter posting yang dikembalikan berdasarkan statusnya. Jadi kita masih akan memiliki tiga variabel berbeda dengan statusnya dan hanya akan membuat satu kueri.

10. Menambahkan index ke kolom yang sering di-queri

Jika Anda membuat kueri dengan menambahkan kondisi where pada kolom berbasis string, lebih baik menambahkan indeks ke kolom. Kueri jauh lebih cepat saat melakukan queri baris dengan kolom indeks.

$posts = Post::where('status','=','published')->get();

Dalam contoh di atas, kita mengkueri record dengan menambahkan kondisi where ke kolom status. Kita dapat meningkatkan kinerja kueri dengan menambahkan migrasi database berikut.

Schema::table('posts', function (Blueprint $table) {
   $table->index('status');
});

11. Gunakan simplePaginate daripada Paginate (biasa)

Saat membuat paginate(), kita biasanya akan melakukannya seperti ini:

$posts = Post::paginate(20);

Ini akan membuat dua kueri, yang pertama untuk mengambil hasil paginasi dan yang kedua untuk menghitung jumlah total baris dalam tabel. Menghitung baris dalam tabel adalah operasi yang lambat dan akan berdampak negatif pada kinerja kueri.

Di sisi lain, melakukan simplePaginate() tidak akan menghitung jumlah total baris dan kueri akan jauh lebih cepat daripada pendekatan paginate(). Tetapi Anda akan kehilangan kemampuan untuk mengetahui nomor halaman terakhir dan dapat melompat ke halaman yang berbeda.

Jika tabel database Anda memiliki banyak baris, lebih baik hindari paginate() dan lakukan simplePaginate() sebagai gantinya.

$posts = Post::paginate(20); // Generates pagination links for all the pages
$posts = Post::simplePaginate(20); // Generates only next and previous pagination links

Kapan untuk menggunakan paginate() dan simplePaginate()?

Lihatlah tabel perbandingan di bawah ini dan tentukan apakah paginate() atau simplePaginate() yang tepat untuk Anda.

Gunakan paginate() jika:

• Diwajibkan untuk memberikan opsi pengguna untuk melompat ke halaman tertentu.
• Diwajibkan itu wajib untuk menunjukkan kepada pengguna jumlah total hasil.

Gunakan simplePaginate() jika:

• Tabel database memiliki begitu banyak baris dan bertumbuh dengan cepat.
• Tidak aktif menggunakan tautan dari pagination.
• UI/UX tidak memengaruhi pengalihan tautan pagination bernomor ke tautan pagination berikutnya/sebelumnya (next/previous)
• Menggunakan tombol “load more” atau “invinite scroll” untuk pagination.

12. Hindari penggunaan awalan wildcards(LIKE keyword)

Saat mencoba melakukan queri hasil yang cocok dengan pola tertentu, kita biasanya menggunakan:

select * from table_name where column like %keyword%

Kueri di atas akan menghasilkan pemindaian tabel penuh. Jika Kita tahu kata kunci muncul di awal nilai kolom, Kita dapat melakukan queri dengan hasil yang sama seperti di bawah ini.

select * from table_name where column like keyword%

13. Hindari penggunaan SQL function di dalam where clause

Selalu lebih baik untuk menghindari SQL function di dalam where clause karena mereka menampilkan hasil dengan cara melakukan pemindaian tabel penuh. Mari kita lihat contoh di bawah ini. Untuk melakukan queri dengan hasil berdasarkan tanggal tertentu, kami biasanya akan melakukan:

$posts = POST::whereDate('created_at', '>=', now() )->get();

Ini akan menghasilkan kueri yang mirip dengan di bawah ini

select * from posts where date(created_at) >= 'timestamp-here'

Kueri di atas akan menghasilkan pemindaian tabel penuh, karena kondisi where tidak diterapkan hingga fungsi date() dieksekusi.

Kita dapat melakukan refactor kode ini untuk menghindari fungsi date() sql seperti di bawah ini:

$posts = Post::where('created_at', '>=', now() )->get();

yang akan menghasilkan queri berikut:

select * from posts where created_at >= 'timestamp-here'

14. Hindari penambahan banyak kolom di dalam tabel database

Lebih baik membatasi jumlah total kolom dalam sebuah tabel. Database relasional seperti mysql, dapat dimanfaatkan untuk membagi tabel dengan begitu banyak kolom menjadi beberapa tabel. Mereka dapat digabungkan bersama dengan menggunakan primary-key dan foreign-key.

Menambahkan terlalu banyak kolom ke tabel akan menambah panjang record individual dan akan memperlambat pemindaian tabel. Saat Anda melakukan kueri select *, Anda akhirnya akan mengambil banyak kolom yang sebenarnya tidak Anda perlukan.

15. Pisahkan kolom dengan tipe data TEXT dari tabel postingan aslinya

>Tip ini berasal dari pengalaman pribadi dan bukan merupakan cara standar untuk merancang tabel database Anda. Saya merekomendasikan untuk ikuti tip ini hanya jika tabel Anda memiliki terlalu banyak record atau akan berkembang pesat (semakin banyak tabel).

Jika suatu tabel memiliki kolom yang menyimpan data dalam jumlah besar (mis: kolom dengan tipe data TEXT), lebih baik dipisahkan mereka ke tabel mereka sendiri atau ke tabel yang akan jarang diminta.

Ketika tabel memiliki kolom dengan sejumlah data besar di dalamnya, ukuran satuan record nya akan tumbuh dengan pesat. Saya secara pribadi mengamatinya memengaruhi waktu kueri di salah satu proyek kami.

Pertimbangkan kasus di mana Anda memiliki tabel yang disebut posting dengan kolom konten yang menyimpan konten posting blog. Konten untuk posting blog akan sangat besar dan sering kali, Anda memerlukan data ini hanya jika seseorang melihatnya di posting blog tertentu.

Jadi memisahkan kolom ini dari tabel posting akan secara drastis meningkatkan kinerja kueri ketika ada terlalu banyak posting.

Berdasarkan yang saya pahami, penulis aslinya bermaksud menggunakan tips ini ketika ingin menampilkan banyak postingan di halaman awal.

16. Cara yang lebih baik ketika ingin mengambil data terbaru dari sebuah tabel

Ketika kita ingin mengambil baris terbaru dari sebuah tabel, kita sering melakukannya dengan cara ini:

$posts = Post::latest()->get();
// or $posts = Post::orderBy('created_at', 'desc')->get();

Pendekatan di atas akan menghasilkan query sql berikut.

select * from posts order by created_at desc

Kueri ini pada dasarnya mengurutkan baris dalam urutan menurun berdasarkan kolom create_at. Karena kolom create_at adalah kolom berbasis string, seringkali lebih lambat untuk mendapatkan hasil dengan cara ini.

Jika tabel database Anda memiliki id primary-key yang auto-increment, maka dalam kebanyakan kasus, baris terbaru akan selalu memiliki id tertinggi. Karena bidang id adalah bidang bilangan bulat dan juga primary-key, jauh lebih cepat untuk mendapatkan hasil berdasarkan key ini. Jadi cara yang lebih baik untuk mengambil baris terbaru adalah seperti di bawah ini.

$posts = Post::latest('id')->get();
// or $posts = Post::orderBy('id', 'desc')->get();

yang akan menghasilkan queri berikut:

select * from posts order by id desc

17. optimasi queri MySQL insert

Sejauh ini kita fokus kepada mengoptimalkan kueri select untuk mendapatkan hasil dari database. Sebagian besar kasus kita hanya perlu mengoptimalkan kueri read. Namun terkadang kita perlu untuk mengoptimalkan kueri insert dan update. Saya menemukan artikel menarik tentang mengoptimalkan insert mysql yang akan membantu dalam mengoptimalkan sisipan dan pembaruan yang lambat.

18. Periksa dan optimasi queri

Tidak ada satu solusi universal saat mengoptimalkan kueri di Laravel. Hanya Anda yang tahu apa yang dilakukan aplikasi Anda, berapa banyak kueri yang dibuat, berapa banyak yang benar-benar digunakan. Jadi memeriksa kueri yang dibuat oleh aplikasi Anda akan membantu Anda menentukan dan mengurangi jumlah total kueri yang dibuat.

Ada alat (baca:tools) tertentu yang membantu Anda dalam memeriksa kueri yang dibuat di setiap halaman.

>Catatan: Disarankan untuk tidak menjalankan salah satu alat ini di environment production Anda. Menjalankan ini di production Anda akan menurunkan kinerja aplikasi Anda dan ketika disusupi, pengguna yang tidak berwenang akan mendapatkan akses ke informasi sensitif.

• Laravel Debugbar — Debugbar Laravel memiliki tab yang disebut database yang akan menampilkan semua kueri yang dijalankan saat Anda mengunjungi halaman. Kunjungi semua halaman di aplikasi Anda dan lihat kueri yang dijalankan di setiap halaman.
• Clockwork — Clockwork sama dengan debugbar laravel. Tetapi alih-alih menyuntikkan tab alat (toolbar) ke situs web Anda, itu akan menampilkan informasi debug di jendela alat pengembang (developer tools) atau sebagai UI yang berdiri sendiri dengan mengunjungi urlaplikasi.test/clockwork.
• Laravel Telescope — Laravel Telescope adalah pendamping debug yang luar biasa saat mengembangkan aplikasi laravel secara lokal. Setelah Teleskop dipasang, Anda dapat mengakses dasbor dengan mengunjungi urlaplikasi.test/telescope Anda. Di dasbor teleskop, buka tab kueri, dan itu akan menampilkan semua kueri yang dieksekusi oleh aplikasi Anda.

Sekian. Semoga bermanfaat.

Artikel ini adalah terjemah dari sini.