Impaginazione di MySQL senza doppia query?

Mi chiedevo se ci fosse un modo per ottenere il numero di risultati da una query MySQL e allo stesso tempo limitare i risultati.

Per come funziona l'impaginazione (per come la intendo io), prima faccio qualcosa di simile

query = SELECT COUNT(*) FROM `table` WHERE `some_condition`

Dopo aver ottenuto num_rows (query), ho il numero di risultati. Ma poi per limitare effettivamente i miei risultati, devo fare una seconda query come:

query2 = SELECT COUNT(*) FROM `table` WHERE `some_condition` LIMIT 0, 10

La mia domanda: è comunque possibile recuperare il numero totale di risultati che sarebbero forniti E limitare i risultati restituiti in una singola query? O un modo più efficiente per farlo. Grazie!

No, è quante applicazioni che vogliono impaginare devono farlo. È affidabile ea prova di proiettile, sebbene esegua la query due volte. Ma puoi memorizzare nella cache il conteggio per alcuni secondi e questo ti aiuterà molto.

L'altro modo è usare la SQL_CALC_FOUND_ROWSclausola e quindi chiamare SELECT FOUND_ROWS(). a parte il fatto che devi mettere la FOUND_ROWS()chiamata in seguito, c'è un problema con questo: c'è un bug in MySQL che questo solletica che influenza le ORDER BYquery rendendole molto più lente su tabelle di grandi dimensioni rispetto all'approccio ingenuo di due query.

Non faccio quasi mai due domande.

Restituire semplicemente una riga in più di quella necessaria, visualizzare solo 10 sulla pagina e, se sono presenti più righe, visualizzare un pulsante "Avanti".

SELECT x, y, z FROM `table` WHERE `some_condition` LIMIT 0, 11

// iterate through and display 10 rows.

// if there were 11 rows, display a "Next" button.

La tua query dovrebbe essere restituita per prima nell'ordine più pertinente. È probabile che alla maggior parte delle persone non interesserà andare a pagina 236 di 412.

Quando esegui una ricerca su Google e i tuoi risultati non sono nella prima pagina, probabilmente vai alla pagina due, non alla nove.

Un altro approccio per evitare la doppia query consiste nel recuperare tutte le righe per la pagina corrente utilizzando prima una clausola LIMIT, quindi eseguire solo una seconda query COUNT (*) se è stato recuperato il numero massimo di righe.

In molte applicazioni, il risultato più probabile sarà che tutti i risultati rientrino in una pagina e dover eseguire l'impaginazione è l'eccezione piuttosto che la norma. In questi casi, la prima query non recupererà il numero massimo di risultati.

Ad esempio, le risposte a una domanda di stackoverflow raramente si riversano su una seconda pagina. I commenti su una risposta raramente superano il limite di 5 o giù di lì richiesto per mostrarli tutti.

Quindi in queste applicazioni puoi semplicemente eseguire prima una query con un LIMIT, quindi finché tale limite non viene raggiunto, sai esattamente quante righe ci sono senza la necessità di eseguire una seconda query COUNT (*), che dovrebbe coprire la maggior parte delle situazioni.

Nella maggior parte delle situazioni è molto più veloce e meno dispendioso in termini di risorse farlo in due query separate che farlo in una, anche se ciò sembra controintuitivo.

Se usi SQL_CALC_FOUND_ROWS, per tabelle di grandi dimensioni la tua query è molto più lenta, significativamente più lenta anche rispetto all'esecuzione di due query, la prima con un COUNT (*) e la seconda con un LIMIT. Il motivo è che SQL_CALC_FOUND_ROWS fa sì che la clausola LIMIT venga applicata dopo recuperato le righe anziché prima, quindi recupera l'intera riga per tutti i risultati possibili prima di applicare i limiti. Questo non può essere soddisfatto da un indice perché recupera effettivamente i dati.

Se adotti l'approccio delle due query, la prima che recupera solo COUNT (*) e non recupera effettivamente i dati effettivi, questo può essere soddisfatto molto più rapidamente perché di solito può utilizzare gli indici e non deve recuperare i dati della riga effettiva per ogni riga che guarda. Quindi, la seconda query deve solo esaminare le prime righe $ offset + $ limit e quindi restituire.

Questo post dal blog sulle prestazioni di MySQL lo spiega ulteriormente:

http://www.mysqlperformanceblog.com/2007/08/28/to-sql_calc_found_rows-or-not-to-sql_calc_found_rows/

Per ulteriori informazioni sull'ottimizzazione dell'impaginazione, controlla questo post e questo post .

La mia risposta potrebbe essere in ritardo, ma puoi saltare la seconda query (con il limite) e filtrare le informazioni tramite il tuo script di back-end. In PHP, ad esempio, potresti fare qualcosa come:

if($queryResult > 0) {
   $counter = 0;
   foreach($queryResult AS $result) {
       if($counter >= $startAt AND $counter < $numOfRows) {
            //do what you want here
       }
   $counter++;
   }
}

Ma ovviamente, quando si hanno migliaia di record da considerare, diventa inefficiente molto rapidamente. Il conteggio pre-calcolato potrebbe essere una buona idea da esaminare.

Ecco una buona lettura sull'argomento: http://www.percona.com/ppc2009/PPC2009_mysql_pagination.pdf

query = SELECT col, col2, (SELECT COUNT(*) FROM `table`) AS total FROM `table` WHERE `some_condition` LIMIT 0, 10

Per chiunque cerchi una risposta nel 2020. Come da documentazione MySQL:

"Il modificatore di query SQL_CALC_FOUND_ROWS e la relativa funzione FOUND_ROWS () sono deprecati a partire da MySQL 8.0.17 e verranno rimossi in una futura versione di MySQL. In sostituzione, considerando di eseguire la query con LIMIT, quindi una seconda query con COUNT (*) e senza LIMIT per determinare se sono presenti righe aggiuntive. "

Immagino che questo risolva tutto.

https://dev.mysql.com/doc/refman/8.0/en/information-functions.html#function_found-rows

È possibile riutilizzare la maggior parte della query in una sottoquery e impostarla su un identificatore. Ad esempio, una query di film che trova film contenenti l'ordinamento della lettera per runtime sarebbe simile a questa sul mio sito.

SELECT Movie.*, (
    SELECT Count(1) FROM Movie
        INNER JOIN MovieGenre 
        ON MovieGenre.MovieId = Movie.Id AND MovieGenre.GenreId = 11
    WHERE Title LIKE '%s%'
) AS Count FROM Movie 
    INNER JOIN MovieGenre 
    ON MovieGenre.MovieId = Movie.Id AND MovieGenre.GenreId = 11
WHERE Title LIKE '%s%' LIMIT 8;

Tieni presente che non sono un esperto di database e spero che qualcuno sarà in grado di ottimizzarlo un po 'meglio. Così com'è, eseguendolo direttamente dall'interfaccia della riga di comando SQL, entrambi impiegano ~ 0,02 secondi sul mio laptop.

SELECT * 
FROM table 
WHERE some_condition 
ORDER BY RAND()
LIMIT 0, 10