MySQL: il modo più veloce per contare il numero di righe

Quale modo per contare un numero di righe dovrebbe essere più veloce in MySQL?

Questo:

SELECT COUNT(*) FROM ... WHERE ...

Oppure, l'alternativa:

SELECT 1 FROM ... WHERE ...

// and then count the results with a built-in function, e.g. in PHP mysql_num_rows()

Si potrebbe pensare che il primo metodo dovrebbe essere più veloce, poiché questo è chiaramente il territorio del database e il motore del database dovrebbe essere più veloce di chiunque altro quando si determinano internamente cose di questo tipo.

Quando si COUNT(*)prende in conto gli indici delle colonne, quindi sarà il miglior risultato. Mysql con MyISAM motore memorizza effettivamente il conteggio delle righe, non conta tutte le righe ogni volta che provi a contare tutte le righe. (in base alla colonna della chiave primaria)

Usare PHP per contare le righe non è molto intelligente, perché devi inviare dati da mysql a php. Perché farlo quando puoi ottenere lo stesso dal lato mysql?

Se COUNT(*)è lento, dovresti eseguire EXPLAINla query e controllare se gli indici sono realmente utilizzati e dove dovrebbero essere aggiunti.

Quanto segue non è il modo più veloce , ma c'è un caso in cui COUNT(*)non si adatta davvero: quando inizi a raggruppare i risultati, puoi incorrere in un problema, in cui COUNTnon conta tutte le righe.

La soluzione è SQL_CALC_FOUND_ROWS. Questo viene solitamente utilizzato quando si selezionano le righe ma è comunque necessario conoscere il conteggio totale delle righe (ad esempio, per la paginazione). Quando selezioni le righe di dati, aggiungi la SQL_CALC_FOUND_ROWSparola chiave dopo SELEZIONA:

SELECT SQL_CALC_FOUND_ROWS [needed fields or *] FROM table LIMIT 20 OFFSET 0;

Dopo aver selezionato le righe necessarie, puoi ottenere il conteggio con questa singola query:

SELECT FOUND_ROWS();

FOUND_ROWS() deve essere chiamato immediatamente dopo la query di selezione dei dati.

In conclusione, tutto si riduce in realtà a quante voci hai e cosa c'è nell'istruzione WHERE. Dovresti davvero prestare attenzione a come vengono utilizzati gli indici, quando ci sono molte righe (decine di migliaia, milioni e oltre).

Dopo aver parlato con i miei compagni di squadra, Ricardo ci ha detto che il modo più veloce è:

show table status like '<TABLE NAME>' \G

Ma devi ricordare che il risultato potrebbe non essere esatto.

Puoi usarlo anche dalla riga di comando:

$ mysqlshow --status <DATABASE> <TABLE NAME>

Maggiori informazioni: http://dev.mysql.com/doc/refman/5.7/en/show-table-status.html

E puoi trovare una discussione completa su mysqlperformanceblog

Ottima domanda, ottime risposte. Ecco un modo rapido per ripetere i risultati se qualcuno sta leggendo questa pagina e manca quella parte:

$counter = mysql_query("SELECT COUNT(*) AS id FROM table");
$num = mysql_fetch_array($counter);
$count = $num["id"];
echo("$count");

Questa query (che è simile a quella pubblicata da bayuah ) mostra un bel riepilogo di tutte le tabelle conteggiate all'interno di un database: (versione semplificata della stored procedure di Ivan Cachicatari che consiglio vivamente).

SELECT TABLE_NAME AS 'Table Name', TABLE_ROWS AS 'Rows' FROM information_schema.TABLES WHERE TABLES.TABLE_SCHEMA = '`YOURDBNAME`' AND TABLES.TABLE_TYPE = 'BASE TABLE'; 

Esempio:

+-----------------+---------+
| Table Name      | Rows    |
+-----------------+---------+
| some_table      |   10278 |
| other_table     |     995 |

Ho sempre capito che quanto segue mi darà i tempi di risposta più rapidi.

SELECT COUNT(1) FROM ... WHERE ...

Se è necessario ottenere il conteggio dell'intero set di risultati, è possibile adottare il seguente approccio:

SELECT SQL_CALC_FOUND_ROWS * FROM table_name LIMIT 5;
SELECT FOUND_ROWS();

Normalmente non è più veloce dell'utilizzo COUNT anche se si potrebbe pensare che sia vero il contrario perché esegue il calcolo internamente e non invia i dati all'utente, quindi si sospetta il miglioramento delle prestazioni.

L'esecuzione di queste due query è utile per l'impaginazione per ottenere i totali ma non particolarmente per l'utilizzo di WHEREclausole.

Ho fatto alcuni benchmark per confrontare il tempo di esecuzione di COUNT(*)vsCOUNT(id) (id è la chiave primaria della tabella - indicizzata).

Numero di prove: 10 * 1000 query

risultati: COUNT(*) è più veloce del 7%

VISUALIZZA GRAFICO: benchmarkgraph

Il mio consiglio è di utilizzare: SELECT COUNT(*) FROM table

Prova questo:

SELECT
    table_rows "Rows Count"
FROM
    information_schema.tables
WHERE
    table_name="Table_Name"
AND
    table_schema="Database_Name";

Forse potresti prendere in considerazione l'idea di fare un file SELECT max(Id) - min(Id) + 1. Funzionerà solo se i tuoi ID sono sequenziali e le righe non vengono eliminate. È comunque molto veloce.

EXPLAIN SELECT id FROM ....ha fatto il trucco per me. e ho potuto vedere il numero di righe sotto la rowscolonna del risultato.

Gestivo tabelle per il governo tedesco con a volte 60 milioni di record.

E dovevamo conoscere molte volte le righe totali.

Così noi programmatori di database abbiamo deciso che in ogni tabella c'è sempre il record uno in cui è memorizzato il numero totale di record. Abbiamo aggiornato questo numero, a seconda delle righe INSERT o DELETE.

Abbiamo provato tutti gli altri modi. Questo è di gran lunga il modo più veloce.

Un'istruzione count (*) con una condizione where sulla chiave primaria ha restituito il conteggio delle righe molto più velocemente per me, evitando la scansione completa della tabella.

SELECT COUNT(*) FROM ... WHERE <PRIMARY_KEY> IS NOT NULL;

Questo è stato molto più veloce per me di

SELECT COUNT(*) FROM ...