Obtenga recuentos de todas las tablas en la base de datos MySQL

Question

¿Hay alguna manera de obtener el recuento de filas en todas las tablas en una base de datos MySQL sin ejecutar SELECT count() en cada tabla?

Answer 1

SELECT SUM(TABLE_ROWS) 
    FROM INFORMATION_SCHEMA.TABLES 
    WHERE TABLE_SCHEMA = '{your_db}'; 

Note from the docs though: Para tablas InnoDB, el número de filas es sólo una estimación aproximada utilizado en la optimización de SQL. Deberá usar COUNT (*) para conteos exactos (que es más caro).

Answer 2

Probablemente pueda poner algo junto con Tables table. Nunca lo he hecho, pero parece que tiene una columna para TABLE_ROWS y una para TABLE NAME.

Para obtener los registros por tabla, se puede utilizar una consulta como esta:

SELECT table_name, table_rows 
FROM INFORMATION_SCHEMA.TABLES 
WHERE TABLE_SCHEMA = '**YOUR SCHEMA**'; 

Answer 3

Este procedimiento almacenado enumera tablas, cuenta registros y produce un número total de registros al final.

Para ejecutarlo después de añadir este procedimiento:

CALL `COUNT_ALL_RECORDS_BY_TABLE`(); 

-

El Procedimiento:

DELIMITER $$ 

CREATE DEFINER=`root`@`127.0.0.1` PROCEDURE `COUNT_ALL_RECORDS_BY_TABLE`() 
BEGIN 
DECLARE done INT DEFAULT 0; 
DECLARE TNAME CHAR(255); 

DECLARE table_names CURSOR for 
    SELECT table_name FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = DATABASE(); 

DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1; 

OPEN table_names; 

DROP TABLE IF EXISTS TCOUNTS; 
CREATE TEMPORARY TABLE TCOUNTS 
    (
    TABLE_NAME CHAR(255), 
    RECORD_COUNT INT 
) ENGINE = MEMORY; 


WHILE done = 0 DO 

    FETCH NEXT FROM table_names INTO TNAME; 

    IF done = 0 THEN 
    SET @SQL_TXT = CONCAT("INSERT INTO TCOUNTS(SELECT '" , TNAME , "' AS TABLE_NAME, COUNT(*) AS RECORD_COUNT FROM ", TNAME, ")"); 

    PREPARE stmt_name FROM @SQL_TXT; 
    EXECUTE stmt_name; 
    DEALLOCATE PREPARE stmt_name; 
    END IF; 

END WHILE; 

CLOSE table_names; 

SELECT * FROM TCOUNTS; 

SELECT SUM(RECORD_COUNT) AS TOTAL_DATABASE_RECORD_CT FROM TCOUNTS; 

END 

Answer 4

Si utiliza el INFORMATION_SCHEMA base de datos, se puede utilizar este código de MySQL (el dónde parte hace que la consulta no muestre las tablas que tienen un valor nulo para las filas):

SELECT TABLE_NAME, TABLE_ROWS 
FROM `TABLES` 
WHERE `TABLE_ROWS` >=0 

Answer 5

Si quiere los números exactos, use la siguiente secuencia de comandos ruby. Necesitas Ruby y RubyGems.

Instalar siguiente: Gemas

$> gem install dbi 
$> gem install dbd-mysql 

del archivo: count_table_records.rb

require 'rubygems' 
require 'dbi' 

db_handler = DBI.connect('DBI:Mysql:database_name:localhost', 'username', 'password') 

# Collect all Tables 
sql_1 = db_handler.prepare('SHOW tables;') 
sql_1.execute 
tables = sql_1.map { |row| row[0]} 
sql_1.finish 

tables.each do |table_name| 
    sql_2 = db_handler.prepare("SELECT count(*) FROM #{table_name};") 
    sql_2.execute 
    sql_2.each do |row| 
    puts "Table #{table_name} has #{row[0]} rows." 
    end 
    sql_2.finish 
end 

db_handler.disconnect 

Volver a la línea de comandos:

$> ruby count_table_records.rb 

Salida:

Table users has 7328974 rows. 

Answer 6

Al igual que @Venkatramanan y otros, encontré que INFORMATION_SCHEMA.TABLES no es confiable (usando InnoDB, MySQL 5.1.44), dando diferentes recuentos de filas cada vez que lo ejecuto, incluso en tablas inmovilizadas. Aquí hay una forma relativamente hacky (pero flexible/adaptable) de generar una gran instrucción SQL que puedes pegar en una nueva consulta, sin instalar gemas de Ruby ni nada por el estilo.

SELECT CONCAT(
    'SELECT "', 
    table_name, 
    '" AS table_name, COUNT(*) AS exact_row_count FROM `', 
    table_schema, 
    '`.`', 
    table_name, 
    '` UNION ' 
) 
FROM INFORMATION_SCHEMA.TABLES 
WHERE table_schema = '**my_schema**'; 

produce una salida como esta:

SELECT "func" AS table_name, COUNT(*) AS exact_row_count FROM my_schema.func UNION       
SELECT "general_log" AS table_name, COUNT(*) AS exact_row_count FROM my_schema.general_log UNION   
SELECT "help_category" AS table_name, COUNT(*) AS exact_row_count FROM my_schema.help_category UNION  
SELECT "help_keyword" AS table_name, COUNT(*) AS exact_row_count FROM my_schema.help_keyword UNION   
SELECT "help_relation" AS table_name, COUNT(*) AS exact_row_count FROM my_schema.help_relation UNION  
SELECT "help_topic" AS table_name, COUNT(*) AS exact_row_count FROM my_schema.help_topic UNION    
SELECT "host" AS table_name, COUNT(*) AS exact_row_count FROM my_schema.host UNION       
SELECT "ndb_binlog_index" AS table_name, COUNT(*) AS exact_row_count FROM my_schema.ndb_binlog_index UNION 

copiar y pegar a excepción de la última UNION para conseguir buena salida como,

+------------------+-----------------+ 
| table_name  | exact_row_count | 
+------------------+-----------------+ 
| func    |    0 | 
| general_log  |    0 | 
| help_category |    37 | 
| help_keyword  |    450 | 
| help_relation |    990 | 
| help_topic  |    504 | 
| host    |    0 | 
| ndb_binlog_index |    0 | 
+------------------+-----------------+ 
8 rows in set (0.01 sec) 

Answer 7

Ésta es la forma en que cuento TABLAS y todos los registros usando PHP:

$dtb = mysql_query("SHOW TABLES") or die (mysql_error()); 
$jmltbl = 0; 
$jml_record = 0; 
$jml_record = 0; 

while ($row = mysql_fetch_array($dtb)) { 
    $sql1 = mysql_query("SELECT * FROM " . $row[0]);    
    $jml_record = mysql_num_rows($sql1);    
    echo "Table: " . $row[0] . ": " . $jml_record record . "<br>";  
    $jmltbl++; 
    $jml_record += $jml_record; 
} 

echo "--------------------------------<br>$jmltbl Tables, $jml_record > records."; 

Answer 8

SELECT TABLE_NAME,SUM(TABLE_ROWS) 
FROM INFORMATION_SCHEMA.TABLES 
WHERE TABLE_SCHEMA = 'your_db' 
GROUP BY TABLE_NAME; 

Eso es todo lo que necesita.

Answer 9

La siguiente consulta produce una consulta (más) que obtendrá el valor de conteo (*) para cada tabla, de cada esquema, enumerada en information_schema.tables. El resultado completo de la consulta que se muestra aquí (todas las filas juntas) comprende una instrucción de SQL válida que termina en un punto y coma, sin 'unión' colgante. La unión colgante se evita mediante el uso de una unión en la siguiente consulta.

select concat('select "', table_schema, '.', table_name, '" as `schema.table`, 
          count(*) 
       from ', table_schema, '.', table_name, ' union ') as 'Query Row' 
    from information_schema.tables 
union 
select '(select null, null limit 0);'; 

Answer 10

solo corro:

show table status; 

Esto le dará el número de filas para cada mesa, más un montón de otra información. Solía ​​usar la respuesta seleccionada anteriormente, pero esto es mucho más fácil.

No estoy seguro de si esto funciona con todas las versiones, pero estoy usando 5.5 con el motor InnoDB.

Answer 11

Puede intentar esto. Está funcionando bien para mí.

SELECT IFNULL(table_schema,'Total') "Database",TableCount 
FROM (SELECT COUNT(1) TableCount,table_schema 
     FROM information_schema.tables 
     WHERE table_schema NOT IN ('information_schema','mysql') 
     GROUP BY table_schema WITH ROLLUP) A; 

Answer 12

Esto es lo que hago para obtener el recuento real (sin usar el esquema)

Es más lento pero más preciso.

Es un proceso de dos pasos en

1. obtener la lista de tablas de su base de datos. Se puede conseguir usando

   mysql -uroot -p mydb -e "show tables" 
   

2. crear y asignar la lista de tablas a la variable de matriz en esta escritura del golpe (separados por un único espacio al igual que en el código de abajo)

   array=(table1 table2 table3) 
   
   for i in "${array[@]}" 
   do 
       echo $i 
       mysql -uroot mydb -e "select count(*) from $i" 
   done 
   

3. Run que:

   chmod +x script.sh; ./script.sh 
   

Answer 13

cartel querido cuenta de las filas sin contar, pero no especificó WH el motor de mesa. Con InnoDB, solo sé de una manera, que es contar.

Esto es como tomo mis papas:

# Put this function in your bash and call with: 
# rowpicker DBUSER DBPASS DBNAME [TABLEPATTERN] 
function rowpicker() { 
    UN=$1 
    PW=$2 
    DB=$3 
    if [ ! -z "$4" ]; then 
     PAT="LIKE '$4'" 
     tot=-2 
    else 
     PAT="" 
     tot=-1 
    fi 
    for t in `mysql -u "$UN" -p"$PW" "$DB" -e "SHOW TABLES $PAT"`;do 
     if [ $tot -lt 0 ]; then 
      echo "Skipping $t"; 
      let "tot += 1"; 
     else 
      c=`mysql -u "$UN" -p"$PW" "$DB" -e "SELECT count(*) FROM $t"`; 
      c=`echo $c | cut -d " " -f 2`; 
      echo "$t: $c"; 
      let "tot += c"; 
     fi; 
    done; 
    echo "total rows: $tot" 
} 

estoy haciendo ninguna afirmación acerca de esto aparte de que esta es una manera muy fea pero eficaz para obtener el número de filas existe en cada tabla en la base de datos sin tener en cuenta del motor de tabla y sin tener que tener permiso para instalar los procedimientos almacenados, y sin la necesidad de instalar ruby ​​o php. Sí, está oxidado. Sí, eso cuenta. contar (*) es exacto.

Answer 14

Si conoce el número de tablas y sus nombres, y suponiendo que cada uno tiene las claves primarias, se puede utilizar una combinación cruzada en combinación con COUNT(distinct [column]) para obtener las filas que vienen de cada tabla:

SELECT 
    COUNT(distinct t1.id) + 
    COUNT(distinct t2.id) + 
    COUNT(distinct t3.id) AS totalRows 
FROM firstTable t1, secondTable t2, thirdTable t3; 

Aquí hay un ejemplo de SQL Fiddle.

Answer 15

Una opción más: para InnoDB no utiliza datos de information_schema.TABLES (ya que es más rápido), para InnoDB - seleccionar conteo (*) para obtener el recuento exacto. También ignora las vistas.

SET @table_schema = DATABASE(); 
-- or SET @table_schema = 'my_db_name'; 

SET GROUP_CONCAT_MAX_LEN=131072; 
SET @selects = NULL; 

SELECT GROUP_CONCAT(
     'SELECT "', table_name,'" as TABLE_NAME, COUNT(*) as TABLE_ROWS FROM `', table_name, '`' 
     SEPARATOR '\nUNION\n') INTO @selects 
    FROM information_schema.TABLES 
    WHERE TABLE_SCHEMA = @table_schema 
     AND ENGINE = 'InnoDB' 
     AND TABLE_TYPE = "BASE TABLE"; 

SELECT CONCAT_WS('\nUNION\n', 
    CONCAT('SELECT TABLE_NAME, TABLE_ROWS FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? AND ENGINE <> "InnoDB" AND TABLE_TYPE = "BASE TABLE"'), 
    @selects) INTO @selects; 

PREPARE stmt FROM @selects; 
EXECUTE stmt USING @table_schema; 
DEALLOCATE PREPARE stmt; 

Si su base de datos tiene muchas tablas InnoDB grandes, contar todas las filas puede llevar más tiempo.

Answer 16

Hay un poco de hack/solución a este problema de estimación.

Auto_Increment: por alguna razón, esto devuelve un recuento de filas mucho más preciso para su base de datos si tiene la configuración de incremento automático en las tablas.

Se encontró esto al explorar por qué la información de la tabla de muestra no coincidía con los datos reales.

SELECT 
table_schema 'Database', 
SUM(data_length + index_length) AS 'DBSize', 
SUM(TABLE_ROWS) AS DBRows, 
SUM(AUTO_INCREMENT) AS DBAutoIncCount 
FROM information_schema.tables 
GROUP BY table_schema; 


+--------------------+-----------+---------+----------------+ 
| Database   | DBSize | DBRows | DBAutoIncCount | 
+--------------------+-----------+---------+----------------+ 
| Core    | 35241984 | 76057 |   8341 | 
| information_schema | 163840 | NULL |   NULL | 
| jspServ   |  49152 |  11 |   856 | 
| mysql    | 7069265 | 30023 |    1 | 
| net_snmp   | 47415296 | 95123 |   324 | 
| performance_schema |   0 | 1395326 |   NULL | 
| sys    |  16384 |  6 |   NULL | 
| WebCal    | 655360 | 2809 |   NULL | 
| WxObs    | 494256128 | 530533 |  3066752 | 
+--------------------+-----------+---------+----------------+ 
9 rows in set (0.40 sec) 

A continuación, puede utilizar fácilmente PHP o lo que sea para volver al máximo de las columnas de datos 2 para dar la "mejor estimación" para el recuento de filas.

decir

SELECT 
table_schema 'Database', 
SUM(data_length + index_length) AS 'DBSize', 
GREATEST(SUM(TABLE_ROWS), SUM(AUTO_INCREMENT)) AS DBRows 
FROM information_schema.tables 
GROUP BY table_schema; 

incremento automático será siempre +1 * (recuento de tabla) filas apagado, pero incluso con 4.000 mesas y 3 millones de filas, eso es 99,9% exacto. Mucho mejor que las filas estimadas.

Lo bueno de esto es que los recuentos de filas devueltos en el esquema de rendimiento también se borran, ya que el máximo no funciona en nulos. Sin embargo, esto puede ser un problema si no tienes tablas con incremento automático.