Esegui una query con LIMIT / OFFSET e ottieni anche il numero totale di righe

Ai fini dell'impaginazione, ho bisogno di eseguire una query con le clausole LIMITe OFFSET. Ma ho anche bisogno di un conteggio del numero di righe che verrebbero restituite da quella query senza le clausole LIMITe OFFSET.

Voglio correre:

SELECT * FROM table WHERE /* whatever */ ORDER BY col1 LIMIT ? OFFSET ?

E:

SELECT COUNT(*) FROM table WHERE /* whatever */

Allo stesso tempo. C'è un modo per farlo, in particolare un modo che consenta a Postgres di ottimizzarlo, in modo che sia più veloce che eseguirli entrambi individualmente?

Sì. Con una semplice funzione finestra:

SELECT *, count(*) OVER() AS full_count
FROM   tbl
WHERE  /* whatever */
ORDER  BY col1
OFFSET ?
LIMIT  ?

Tieni presente che il costo sarà notevolmente superiore rispetto a quello senza il numero totale, ma in genere ancora più economico di due query separate. Postgres deve effettivamente contare tutte le righe in entrambi i modi, il che impone un costo in base al numero totale di righe qualificate. Dettagli:

• Il modo migliore per ottenere il conteggio dei risultati prima dell'applicazione di LIMIT

Tuttavia , come ha sottolineato Dani , quando OFFSETè grande almeno quanto il numero di righe restituite dalla query di base, non viene restituita alcuna riga. Quindi anche noi non otteniamo full_count.

Se ciò non è accettabile, una possibile soluzione alternativa per restituire sempre il conteggio completo sarebbe con un CTE e un OUTER JOIN:

WITH cte AS (
   SELECT *
   FROM   tbl
   WHERE  /* whatever */
   )
SELECT *
FROM  (
   TABLE  cte
   ORDER  BY col1
   LIMIT  ?
   OFFSET ?
   ) sub
RIGHT  JOIN (SELECT count(*) FROM cte) c(full_count) ON true;

Ottieni una riga di valori NULL con l' full_countaggiunta se OFFSETè troppo grande. Altrimenti, viene aggiunto a ogni riga come nella prima query.

Se una riga con tutti i valori NULL è un possibile risultato valido, è necessario verificare offset >= full_countper disambiguare l'origine della riga vuota.

Ciò esegue ancora la query di base solo una volta. Ma aggiunge più overhead alla query e paga solo se è inferiore alla ripetizione della query di base per il conteggio.

Se sono disponibili indici che supportano l'ordinamento finale, potrebbe essere conveniente includerli ORDER BYnella CTE (in modo ridondante).

modifica: questa risposta è valida quando si recupera la tabella non filtrata. Lo lascerò nel caso possa aiutare qualcuno, ma potrebbe non rispondere esattamente alla domanda iniziale.

La risposta di Erwin Brandstetter è perfetta se hai bisogno di un valore accurato. Tuttavia, su tavoli di grandi dimensioni spesso è necessaria solo un'approssimazione piuttosto buona. Postgres ti dà proprio questo e sarà molto più veloce in quanto non avrà bisogno di valutare ogni riga:

SELECT *
FROM (
    SELECT *
    FROM tbl
    WHERE /* something */
    ORDER BY /* something */
    OFFSET ?
    LIMIT ?
    ) data
RIGHT JOIN (SELECT reltuples FROM pg_class WHERE relname = 'tbl') pg_count(total_count) ON true;

In realtà non sono abbastanza sicuro se ci sia un vantaggio per esternalizzare RIGHT JOINo averlo come in una query standard. Meriterebbe qualche prova.

SELECT t.*, pgc.reltuples AS total_count
FROM tbl as t
RIGHT JOIN pg_class pgc ON pgc.relname = 'tbl'
WHERE /* something */
ORDER BY /* something */
OFFSET ?
LIMIT ?

Anche se la risposta di Erwin Brandstetter funziona come un fascino, restituisce il conteggio totale delle righe in ogni riga come segue:

col1 - col2 - col3 - total
--------------------------
aaaa - aaaa - aaaa - count
bbbb - bbbb - bbbb - count
cccc - cccc - cccc - count

Potresti prendere in considerazione l'utilizzo di un approccio che restituisca il conteggio totale solo una volta , come il seguente:

total - rows
------------
count - [{col1: 'aaaa'},{col2: 'aaaa'},{col3: 'aaaa'}
         {col1: 'bbbb'},{col2: 'bbbb'},{col3: 'bbbb'}
         {col1: 'cccc'},{col2: 'cccc'},{col3: 'cccc'}]

Query SQL:

SELECT 
    (SELECT COUNT(*) FROM table) as count, 
    (SELECT json_agg(t.*) FROM (
        SELECT * FROM table
        WHERE /* whatever */
        ORDER BY col1
        OFFSET ?
        LIMIT ?
    ) AS t) AS rows 

È una cattiva pratica chiamare due volte la stessa query solo per ottenere il numero totale di righe del risultato di ritorno. Ci vorrà tempo di esecuzione e sprecherà la risorsa del server.

Meglio, puoi usare SQL_CALC_FOUND_ROWSnella query che dirà a MySQL di recuperare il numero totale di conteggi di righe insieme ai risultati della query limite.

Esempio impostato come:

SELECT SQL_CALC_FOUND_ROWS employeeName, phoneNumber FROM employee WHERE employeeName LIKE 'a%' LIMIT 10;

SELECT FOUND_ROWS();

Nella query precedente, aggiungi semplicemente l' SQL_CALC_FOUND_ROWSopzione nel resto della query richiesta ed esegui la seconda riga, ovvero SELECT FOUND_ROWS()restituisce il numero di righe nel set di risultati restituito da tale istruzione.

No.

C'è forse qualche piccolo guadagno che potresti teoricamente ottenere eseguendoli individualmente con macchinari abbastanza complicati sotto il cofano. Tuttavia, se vuoi sapere quante righe corrispondono a una condizione, dovrai contarle anziché solo un sottoinsieme LIMITATO.