Manera rápida de descubrir el recuento de filas de una tabla en PostgreSQL

Necesito saber el número de filas en una tabla para calcular un porcentaje. Si el recuento total es mayor que alguna constante predefinida, usaré el valor constante. De lo contrario, usaré el número real de filas.

Puedo usar SELECT count(*) FROM table. Pero si mi valor constante es 500,000 y tengo 5,000,000,000 filas en mi tabla, contar todas las filas desperdiciará mucho tiempo.

¿Es posible dejar de contar tan pronto como se supere mi valor constante?

Solo necesito el número exacto de filas siempre que esté por debajo del límite dado. De lo contrario, si el recuento está por encima del límite, utilizo el valor límite y quiero la respuesta lo más rápido posible.

Algo como esto:

SELECT text,count(*), percentual_calculus()  
FROM token  
GROUP BY text  
ORDER BY count DESC;

Se sabe que el recuento de filas en tablas grandes es lento en PostgreSQL. Para obtener un número preciso, debe realizar un recuento completo de filas debido a la naturaleza de MVCC . Hay una manera de acelerar esto drásticamente si el recuento no tiene que ser exacto como parece ser en su caso.

En lugar de obtener el recuento exacto ( lento con tablas grandes):

SELECT count(*) AS exact_count FROM myschema.mytable;

Obtienes una estimación cercana como esta ( extremadamente rápido ):

SELECT reltuples::bigint AS estimate FROM pg_class where relname='mytable';

Qué tan cerca esté la estimación depende de si corres lo ANALYZEsuficiente. Suele estar muy cerca.
Consulte las preguntas frecuentes de la Wiki de PostgreSQL .
O la página wiki dedicada para el rendimiento de conteo (*) .

Mejor todavía

El artículo en el PostgreSQL Wiki se fue un poco descuidado . Ignoró la posibilidad de que pueda haber varias tablas con el mismo nombre en una base de datos, en diferentes esquemas. Para dar cuenta de eso:

SELECT c.reltuples::bigint AS estimate
FROM   pg_class c
JOIN   pg_namespace n ON n.oid = c.relnamespace
WHERE  c.relname = 'mytable'
AND    n.nspname = 'myschema'

O mejor aun

SELECT reltuples::bigint AS estimate
FROM   pg_class
WHERE  oid = 'myschema.mytable'::regclass;

Más rápido, más simple, más seguro, más elegante. Consulte el manual sobre tipos de identificadores de objetos .

Úselo to_regclass('myschema.mytable')en Postgres 9.4+ para evitar excepciones para nombres de tablas no válidos:

• Cómo comprobar si existe una tabla en un esquema determinado

TABLESAMPLE SYSTEM (n) en Postgres 9.5+

SELECT 100 * count(*) AS estimate FROM mytable TABLESAMPLE SYSTEM (1);

Como comentó @a_horse , la cláusula recién agregada para el SELECTcomando podría ser útil si las estadísticas en pg_classno están lo suficientemente actualizadas por alguna razón. Por ejemplo:

• No autovacuumcorrer.
• Inmediatamente después de un gran INSERTo DELETE.
• TEMPORARYtablas (que no están cubiertas por autovacuum).

Esto solo mira una selección aleatoria de bloques n % ( 1en el ejemplo) y cuenta las filas en ella. Una muestra más grande aumenta el costo y reduce el error, su elección. La precisión depende de más factores:

• Distribución del tamaño de las filas. Si un bloque dado tiene filas más anchas de lo habitual, el recuento es más bajo de lo habitual, etc.
• Tuplas muertas o un FILLFACTORespacio ocupado por bloque. Si se distribuye de manera desigual en la tabla, es posible que la estimación sea incorrecta.
• Errores generales de redondeo.

En la mayoría de los casos, la estimación de pg_classserá más rápida y precisa.

Respuesta a la pregunta real

Primero, necesito saber el número de filas en esa tabla, si el recuento total es mayor que alguna constante predefinida,

Y si ...

... es posible en el momento en que el conteo pase mi valor constante, se detendrá el conteo (y no esperará a terminar el conteo para informar que el conteo de filas es mayor).

Si. Puede usar una subconsulta conLIMIT :

SELECT count(*) FROM (SELECT 1 FROM token LIMIT 500000) t;

Postgres realmente deja de contar más allá del límite dado, obtiene un recuento exacto y actual para hasta n filas (500000 en el ejemplo) y n de lo contrario. Sin pg_classembargo, no tan rápido como la estimación .

Hice esto una vez en una aplicación de postgres ejecutando:

EXPLAIN SELECT * FROM foo;

Luego, examina la salida con una expresión regular o una lógica similar. Para un SELECT * simple, la primera línea de salida debería verse así:

Seq Scan on uids  (cost=0.00..1.21 rows=8 width=75)

Puede usar el rows=(\d+)valor como una estimación aproximada del número de filas que se devolverán, luego solo haga el valor real SELECT COUNT(*)si la estimación es, digamos, menos de 1,5 veces su umbral (o cualquier número que considere que tiene sentido para su aplicación).

Según la complejidad de su consulta, este número puede volverse cada vez menos preciso. De hecho, en mi aplicación, a medida que agregamos uniones y condiciones complejas, se volvió tan inexacto que fue completamente inútil, incluso para saber cómo dentro de una potencia de 100 cuántas filas habríamos devuelto, por lo que tuvimos que abandonar esa estrategia.

Pero si su consulta es lo suficientemente simple como para que Pg pueda predecir con un margen de error razonable cuántas filas devolverá, puede funcionar para usted.

Referencia extraída de este Blog.

Puede utilizar a continuación para consultar y encontrar el recuento de filas.

Usando pg_class:

 SELECT reltuples::bigint AS EstimatedCount
    FROM   pg_class
    WHERE  oid = 'public.TableName'::regclass;

Usando pg_stat_user_tables:

SELECT 
    schemaname
    ,relname
    ,n_live_tup AS EstimatedCount 
FROM pg_stat_user_tables 
ORDER BY n_live_tup DESC;

En Oracle, puede utilizar rownumpara limitar el número de filas devueltas. Supongo que también existe una construcción similar en otros SQL. Entonces, para el ejemplo que dio, podría limitar el número de filas devueltas a 500001 y aplicar un count(*)entonces:

SELECT (case when cnt > 500000 then 500000 else cnt end) myCnt
FROM (SELECT count(*) cnt FROM table WHERE rownum<=500001)

¿Qué tan ancha es la columna de texto?

Con GROUP BY no hay mucho que pueda hacer para evitar un escaneo de datos (al menos un escaneo de índice).

Yo lo recomiendo:

1. Si es posible, cambie el esquema para eliminar la duplicación de datos de texto. De esta manera, el recuento ocurrirá en un campo de clave externa estrecho en la tabla 'muchos'.

2. Alternativamente, crear una columna generada con un HASH del texto, luego AGRUPAR POR la ​​columna de hash. Nuevamente, esto es para disminuir la carga de trabajo (escanee a través de un índice de columna estrecho)

Editar:

Tu pregunta original no coincidía con tu edición. No estoy seguro de si sabe que COUNT, cuando se usa con GROUP BY, devolverá el recuento de elementos por grupo y no el recuento de elementos en toda la tabla.

Puede obtener el recuento mediante la siguiente consulta (sin * ni ningún nombre de columna).

select from table_name;

Para SQL Server (2005 o superior), un método rápido y confiable es:

SELECT SUM (row_count)
FROM sys.dm_db_partition_stats
WHERE object_id=OBJECT_ID('MyTableName')   
AND (index_id=0 or index_id=1);

Los detalles sobre sys.dm_db_partition_stats se explican en MSDN

La consulta agrega filas de todas las partes de una tabla (posiblemente) particionada.

index_id = 0 es una tabla desordenada (Heap) e index_id = 1 es una tabla ordenada (índice agrupado)

Aquí se detallan métodos aún más rápidos (pero poco fiables) .