Mana yang tercepat? SELECT SQL_CALC_FOUND_ROWS DARI `table`, atau SELECT COUNT (*)

Saat Anda membatasi jumlah baris yang akan dikembalikan oleh kueri SQL, biasanya digunakan dalam paging, ada dua metode untuk menentukan jumlah total catatan:

Metode 1

Sertakan SQL_CALC_FOUND_ROWSopsi dalam yang asli SELECT, dan kemudian dapatkan jumlah total baris dengan menjalankan SELECT FOUND_ROWS():

SELECT SQL_CALC_FOUND_ROWS * FROM table WHERE id > 100 LIMIT 10;
SELECT FOUND_ROWS();  

Metode 2

Jalankan kueri secara normal, lalu dapatkan jumlah total baris dengan menjalankan SELECT COUNT(*)

SELECT * FROM table WHERE id > 100 LIMIT 10;
SELECT COUNT(*) FROM table WHERE id > 100;  

Metode mana yang terbaik / tercepat?

Tergantung. Lihat posting Blog Kinerja MySQL tentang hal ini: http://www.mysqlperformanceblog.com/2007/08/28/to-sql_calc_found_rows-or-not-to-sql_calc_found_rows/

Hanya ringkasan singkat: Peter mengatakan bahwa itu tergantung pada indeks Anda dan faktor lainnya. Banyak komentar di posting ini sepertinya mengatakan bahwa SQL_CALC_FOUND_ROWS hampir selalu lebih lambat - terkadang hingga 10x lebih lambat - daripada menjalankan dua kueri.

Saat memilih pendekatan "terbaik", pertimbangan yang lebih penting daripada kecepatan mungkin adalah pemeliharaan dan kebenaran kode Anda. Jika demikian, SQL_CALC_FOUND_ROWS lebih disukai karena Anda hanya perlu mempertahankan satu permintaan. Menggunakan satu kueri benar-benar menghalangi kemungkinan perbedaan halus antara kueri utama dan jumlah, yang dapat menyebabkan COUNT tidak akurat.

MySQL telah mulai SQL_CALC_FOUND_ROWSmenghilangkan fungsionalitas dengan versi 8.0.17 dan seterusnya.

Jadi, selalu lebih disukai untuk mempertimbangkan mengeksekusi kueri Anda dengan LIMIT, dan kemudian kueri kedua dengan COUNT(*)dan tanpa LIMITmenentukan apakah ada baris tambahan.

Dari dokumen :

SQL_CALC_FOUND_ROWS pengubah permintaan dan fungsi FOUND_ROWS () yang menyertainya tidak digunakan pada MySQL 8.0.17 dan akan dihapus dalam versi MySQL yang akan datang.

COUNT (*) tunduk pada optimasi tertentu. SQL_CALC_FOUND_ROWS menyebabkan beberapa optimasi dinonaktifkan.

Gunakan kueri ini sebagai gantinya:

SELECT * FROM tbl_name WHERE id > 100 LIMIT 10;
SELECT COUNT(*) WHERE id > 100;

Juga, SQL_CALC_FOUND_ROWStelah diamati memiliki lebih banyak masalah secara umum, seperti yang dijelaskan dalam MySQL WL # 12615 :

SQL_CALC_FOUND_ROWS memiliki sejumlah masalah. Pertama-tama, lambat. Seringkali, akan lebih murah untuk menjalankan kueri dengan LIMIT dan kemudian SELECT COUNT terpisah ( ) untuk permintaan yang sama, karena COUNT ( ) dapat menggunakan pengoptimalan yang tidak dapat dilakukan ketika mencari seluruh rangkaian hasil (misalnya filesort dapat diabaikan untuk COUNT (*), sedangkan dengan CALC_FOUND_ROWS, kita harus menonaktifkan beberapa optimisasi fileort untuk menjamin hasil yang benar)

Lebih penting lagi, ini memiliki semantik yang sangat tidak jelas dalam sejumlah situasi. Secara khusus, ketika sebuah kueri memiliki beberapa blok kueri (misalnya dengan UNION), tidak ada cara untuk menghitung jumlah baris "yang akan pernah" pada saat yang sama dengan menghasilkan kueri yang valid. Ketika eksekutator iterator mengalami kemajuan ke arah pertanyaan semacam ini, sungguh sulit untuk mencoba mempertahankan semantik yang sama. Selain itu, jika ada beberapa LIMIT dalam kueri (misalnya untuk tabel turunan), itu tidak harus jelas ke yang SQL_CALC_FOUND_ROWS mana yang harus dirujuk. Dengan demikian, pertanyaan nontrivial seperti itu tentu akan mendapatkan semantik yang berbeda dalam pelaksana iterator dibandingkan dengan yang mereka miliki sebelumnya.

Akhirnya, sebagian besar kasus penggunaan di mana SQL_CALC_FOUND_ROWS tampaknya berguna harus diselesaikan dengan mekanisme lain selain LIMIT / OFFSET. Misalnya, buku telepon harus diberi nomor halaman dengan huruf (baik dalam hal UX dan dalam hal penggunaan indeks), bukan dengan mencatat nomor. Diskusi semakin tak terbatas-gulir dipesan berdasarkan tanggal (sekali lagi memungkinkan penggunaan indeks), bukan oleh paginasi oleh nomor pos. Dan seterusnya.

Menurut artikel berikut: https://www.percona.com/blog/2007/08/28/to-sql_calc_found_rows-or-not-to-sql_calc_found_rows/

Jika Anda memiliki INDEKS pada klausa tempat Anda (jika id diindeks pada kasus Anda), maka lebih baik untuk tidak menggunakan SQL_CALC_FOUND_ROWS dan menggunakan 2 kueri sebagai gantinya, tetapi jika Anda tidak memiliki indeks pada apa yang Anda masukkan dalam klausa mana Anda (id dalam kasus Anda) kemudian menggunakan SQL_CALC_FOUND_ROWS lebih efisien.

IMHO, alasan mengapa 2 pertanyaan

SELECT * FROM count_test WHERE b = 666 ORDER BY c LIMIT 5;
SELECT count(*) FROM count_test WHERE b = 666;

lebih cepat daripada menggunakan SQL_CALC_FOUND_ROWS

SELECT SQL_CALC_FOUND_ROWS * FROM count_test WHERE b = 555 ORDER BY c LIMIT 5;

harus dilihat sebagai kasus tertentu.

Itu sebenarnya tergantung pada selektivitas klausa WHERE dibandingkan dengan selektivitas implisit yang setara dengan ORDER + LIMIT.

Seperti yang dikatakan oleh Arvids dalam komentar ( http://www.mysqlperformanceblog.com/2007/08/28/to-sql_calc_found_rows-or-not-to-sql_calc_found_rows/#comment-1174394 ), fakta bahwa EXPLAIN menggunakan, atau tidak, tabel temporay, harus menjadi dasar yang baik untuk mengetahui apakah SCFR akan lebih cepat atau tidak.

Tetapi, seperti yang saya tambahkan ( http://www.mysqlperformanceblog.com/2007/08/28/to-sql_calc_found_rows-or-not-to-sql_calc_found_rows/#comment-8166482 ), hasilnya benar-benar tergantung pada kasusnya. Untuk paginator tertentu, Anda bisa sampai pada kesimpulan bahwa “untuk 3 halaman pertama, gunakan 2 pertanyaan; untuk halaman-halaman berikut, gunakan SCFR ”!

Menghapus beberapa SQL yang tidak perlu dan kemudian COUNT(*)akan lebih cepat dari SQL_CALC_FOUND_ROWS. Contoh:

SELECT Person.Id, Person.Name, Job.Description, Card.Number
FROM Person
JOIN Job ON Job.Id = Person.Job_Id
LEFT JOIN Card ON Card.Person_Id = Person.Id
WHERE Job.Name = 'WEB Developer'
ORDER BY Person.Name

Kemudian hitung tanpa bagian yang tidak perlu:

SELECT COUNT(*)
FROM Person
JOIN Job ON Job.Id = Person.Job_Id
WHERE Job.Name = 'WEB Developer'

Ada opsi lain yang bisa Anda tolak:

1.) Fungsi jendela akan mengembalikan ukuran aktual secara langsung (diuji dalam MariaDB):

SELECT 
  `mytable`.*,
  COUNT(*) OVER() AS `total_count`
FROM `mytable`
ORDER BY `mycol`
LIMIT 10, 20

2.) Berpikir di luar kotak, sebagian besar waktu pengguna tidak perlu mengetahui ukuran EXACT dari tabel, perkiraan seringkali cukup baik.

SELECT `TABLE_ROWS` AS `rows_approx`
FROM `INFORMATION_SCHEMA`.`TABLES`
WHERE `TABLE_SCHEMA` = DATABASE()
  AND `TABLE_TYPE` = "BASE TABLE"
  AND `TABLE_NAME` = ?