计算一个非常大的表中确切行数的最快方法？

Question

我遇到过一些文章指出，当表格有很多行和很多列时，SELECT COUNT(*) FROM TABLE_NAME 会很慢。

我有一个可能包含数十亿行的表 [它大约有 15 列]。有没有更好的方法来获取表格行数的EXACT计数？

请在回答之前考虑以下几点：

• 我正在寻找数据库供应商 独立解决方案。如果是就OK 涵盖 MySQL、Oracle、MS SQL Server。 但是如果有真的没有数据库 供应商独立解决方案然后我 将满足于不同的解决方案 针对不同的数据库供应商。

• 我无法使用任何其他外部工具 去做这个。我主要是找一个 基于 SQL 的解决方案。

• 我无法规范化我的数据库设计 任何进一步。它已经在 3NF 中，而且是 很多代码已经写好了 在它周围。

Answer 1

使用 SQL Server 2019，您可以使用 APPROX_COUNT_DISTINCT，其中：

返回组中唯一非空值的近似数量

并且来自文档：

APPROX_COUNT_DISTINCT 专为在大数据场景中使用而设计，是 针对以下条件进行了优化：

• 访问数百万行或更多行的数据集，并且
• 聚合具有许多不同值的一列或多列

还有函数

• 实施保证在 97% 的概率内错误率高达 2%
• 比穷举 COUNT DISTINCT 操作需要更少的内存
• 与精确的 COUNT DISTINCT 操作相比，较小的内存占用不太可能将内存溢出到磁盘。

实现背后的算法是HyperLogLog。

Answer 2

对我来说，在一张非常大的桌子上，

SELECT COUNT(1) FROM TableLarge 

需要 37 秒，而

SELECT COUNT_BIG(1) FROM TableLarge

需要 4 秒。

Answer 3

可能有点晚了，但这可能对其他人的 MSSQL 有所帮助

;WITH RecordCount AS (  SELECT      ROW_NUMBER() OVER (ORDER BY
COLUMN_NAME) AS [RowNumber]     FROM        TABLE_NAME )  SELECT
MAX(RowNumber) FROM RecordCount

Answer 4

select rows from sysindexes
where id = Object_ID('TableName') and indid <2

Answer 5

在 SQL Server 2016 中，我可以检查表属性，然后选择“存储”选项卡 - 这会显示行数、表使用的磁盘空间、使用的索引空间等。

Answer 6

使用 PostgreSQL：

SELECT reltuples AS approximate_row_count FROM pg_class WHERE relname = 'table_name'

Answer 7

我从另一个 StackOverflow 问题/答案中得到了这个脚本：

SELECT SUM(p.rows) FROM sys.partitions AS p
  INNER JOIN sys.tables AS t
  ON p.[object_id] = t.[object_id]
  INNER JOIN sys.schemas AS s
  ON s.[schema_id] = t.[schema_id]
  WHERE t.name = N'YourTableNameHere'
  AND s.name = N'dbo'
  AND p.index_id IN (0,1);

我的表有 5 亿条记录，上述返回时间不到 1 毫秒。 同时，

SELECT COUNT(id) FROM MyTable

需要整整 39 分 52 秒！

它们产生完全相同的行数（在我的例子中，正好是 519326012）。

我不知道会不会一直这样。

Answer 8

我从martijnh1 中找到了这篇好文章SQL Server–HOW-TO: quickly retrieve accurate row count for table，它对每个场景进行了很好的回顾。

我需要在需要根据特定条件提供计数的地方对此进行扩展，当我计算出这部分时，我会进一步更新这个答案。

同时，以下是文章中的详细信息：

方法一：

查询：

SELECT COUNT(*) FROM Transactions 

评论：

执行全表扫描。在大桌子上慢。

方法二：

查询：

SELECT CONVERT(bigint, rows) 
FROM sysindexes 
WHERE id = OBJECT_ID('Transactions') 
AND indid < 2 

评论：

检索行数的快速方法。取决于统计数据，不准确。

使用 COUNT_ROWS 运行 DBCC UPDATEUSAGE(Database)，这对于大型表可能会花费大量时间。

方法三：

查询：

SELECT CAST(p.rows AS float) 
FROM sys.tables AS tbl 
INNER JOIN sys.indexes AS idx ON idx.object_id = tbl.object_id and
idx.index_id < 2 
INNER JOIN sys.partitions AS p ON p.object_id=CAST(tbl.object_id AS int) 
AND p.index_id=idx.index_id 
WHERE ((tbl.name=N'Transactions' 
AND SCHEMA_NAME(tbl.schema_id)='dbo')) 

评论：

SQL 管理工作室计算行数的方式（查看表属性、存储、行数）。非常快，但仍然是近似的行数。

方法四：

查询：

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

评论：

快速（虽然不如方法 2 快）操作且同样重要、可靠。

Answer 9

简单回答：

• 数据库供应商独立解决方案 = 使用标准 = COUNT(*)
• 有近似 SQL Server 解决方案，但不使用 COUNT(*) = out of scope

注意事项：

COUNT(1) = COUNT(*) = COUNT(PrimaryKey)以防万一

编辑：

SQL Server 示例（14 亿行，12 列）

SELECT COUNT(*) FROM MyBigtable WITH (NOLOCK)
-- NOLOCK here is for me only to let me test for this answer: no more, no less

1 次跑步，5:46 分钟，计数 = 1,401,659,700

--Note, sp_spaceused uses this DMV
SELECT
   Total_Rows= SUM(st.row_count)
FROM
   sys.dm_db_partition_stats st
WHERE
    object_name(object_id) = 'MyBigtable' AND (index_id < 2)

2 次运行，均在 1 秒内，计数 = 1,401,659,670

第二个行数少 = 错误。取决于写入是否相同或更多（删除是在几个小时内完成的）

Answer 10

对于 Sql server 试试这个

SELECT T.name, 
       I.rows AS [ROWCOUNT] 
FROM   sys.tables AS T 
       INNER JOIN sys.sysindexes AS I 
               ON T.object_id = I.id AND I.indid < 2 
WHERE T.name = 'Your_Table_Name'
ORDER  BY I.rows DESC 

Answer 11

我迟到了这个问题，但这是你可以用 MySQL 做的事情（因为我使用 MySQL）。我在这里分享我的观察：

1) SELECT COUNT(*) AS TOTAL_ROWS FROM <TABLE_NAME>

结果
行数：508534
控制台输出：受影响的行：0 找到的行：1 警告：0 1 次查询的持续时间：0.125 秒。
对于具有大量行的表需要一段时间，但行数非常准确。

2) SHOW TABLE STATUS or SHOW TABLE STATUS WHERE NAME="<TABLE_NAME>"

结果
行数：511235
控制台输出：受影响的行：0 找到的行：1 警告：0 1 次查询的持续时间：0.250 秒 摘要：行数不准确。

3) SELECT * FROM information_schema.tables WHERE table_schema = DATABASE();

结果
行数：507806
控制台输出：受影响的行：0 找到的行：48 警告：0 1 次查询的持续时间：1.701 秒。
行数不准确。

我不是 MySQL 或数据库专家，但我发现对于非常大的表，您可以使用选项 2 或 3 并“大致了解”存在多少行。

我需要获取这些行数以在 UI 上显示一些统计信息。通过上述查询，我​​知道总行数超过 500,000，因此我想出了显示“超过 500,000 行”之类的统计信息，但没有显示确切的行数。

也许我还没有真正回答 OP 的问题，但我正在分享我在需要此类统计数据的情况下所做的事情。在我的情况下，显示近似行是可以接受的，所以上面的方法对我有用。

Answer 12

如果 insert trigger 使用成本太高，但可以提供 delete trigger，并且有自动增量id，然后在计算整个表一次后，并记住计数为last-count 和last-counted-id，

然后每天只需计算id > last-counted-id，将其添加到last-count，并存储新的last-counted-id。

如果已删除记录的 id

Answer 13

好吧，晚了 5 年，不确定是否有帮助：

我试图数数。使用 MS SQL Server Management Studio 的 SQL Server 表中的行数并遇到一些溢出错误，然后我使用了以下内容：

选择 count_big(1) FROM [dbname].[dbo].[FactSampleValue];

结果：

24296650578 行

Answer 14

如果您使用的是 Oracle，这个怎么样（假设表统计信息已更新）：

select <TABLE_NAME>, num_rows, last_analyzed from user_tables

last_analyzed 将显示上次收集统计数据的时间。

Answer 15

如果您的典型表结构具有自动递增的主键列，其中的行永远不会被删除，那么以下将是确定记录计数的最快方法，并且在大多数符合 ANSI 的数据库中都应该类似地工作：

SELECT TOP(1) <primarykeyfield> FROM <table> ORDER BY <primarykeyfield> DESC;

我使用包含数十亿行的 MS SQL 表，这些表需要亚秒级的数据响应时间，包括记录计数。相比之下，类似的 SELECT COUNT(*) 需要几分钟来处理。

Answer 16

一个真正疯狂的答案，但是如果您设置了某种复制系统（对于具有十亿行的系统，我希望您这样做），您可以使用粗略估计器（如 MAX(pk)），除以根据您拥有的从属设备数量计算值，并行运行多个查询。

在大多数情况下，您会根据最佳键（或我猜的主键）在从属之间划分查询，以这种方式（我们将使用 250000000 作为我们的行/从属）：

-- First slave
SELECT COUNT(pk) FROM t WHERE pk < 250000000
-- Ith slave where 2 <= I <= N - 1
SELECT COUNT(pk) FROM t WHERE pk >= I*250000000 and pk < (I+1)*250000000
-- Last slave
SELECT COUNT(pk) FROM t WHERE pk > (N-1)*250000000

但您只需要 SQL。什么胸围。好吧，假设你是一个施虐狂。 在主服务器（或最近的从服务器）上，您很可能需要为此创建一个表：

CREATE TABLE counter_table (minpk integer, maxpk integer, cnt integer, slaveid integer)

因此，您必须执行插入操作，而不是只在您的从属服务器中运行选择：

INSERT INTO counter_table VALUES (I*25000000, (I+1)*250000000, (SELECT COUNT(pk) FROM ... ), @@SLAVE_ID)

您可能会遇到从服务器写入主服务器表的问题。你可能需要获得更多的萨迪斯——我的意思是，有创意：

-- A table per slave!
INSERT INTO counter_table_slave_I VALUES (...)

你最终应该有一个从站，它存在于复制图遍历的路径中，相对于第一个从站。该从站现在应该具有所有其他计数器值，并且应该具有自己的值。但是当您完成时，可能已经添加了行，因此您必须插入另一行来补偿 counter_table 中记录的最大 pk 和当前的最大 pk。

此时，您必须执行聚合函数来计算总行数，但这更容易，因为您最多可以在“您拥有和更改的从属设备数量”行上运行它。

如果您的从属服务器中有单独的表，您可以UNION 获取您需要的所有行。

SELECT SUM(cnt) FROM (
    SELECT * FROM counter_table_slave_1
      UNION
    SELECT * FROM counter_table_slave_2
      UNION
    ...
  )

或者您知道，不要那么疯狂，将您的数据迁移到分布式处理系统，或者使用数据仓库解决方案（这也将在未来为您提供出色的数据处理能力）。

请注意，这确实取决于您的复制设置的好坏。由于主要瓶颈很可能是持久性存储，因此如果您的存储很脏或者数据存储隔离不良且邻居噪音很大，那么这可能会让您比只等待单个 SELECT COUNT(*) ... 慢一点。

但是如果你有良好的复制，那么你的速度增益应该直接与数量或从属服务器相关。事实上，如果单独运行计数查询需要 10 分钟，并且您有 8 个从站，您可以将时间缩短到不到几分钟。可能需要一个小时来解决这个解决方案的细节。

当然，您永远不会真正得到一个非常准确的答案，因为这种分布式求解引入了一些可以删除和插入行的时间，但是您可以尝试在同一实例中获取行的分布式锁并获得特定时刻表中行的精确计数。

实际上，这似乎是不可能的，因为您基本上被困在仅使用 SQL 的解决方案中，而且我认为您没有提供一种机制来立即跨多个从属服务器运行分片和锁定查询。也许如果您控制了复制日志文件...这意味着您实际上会为此目的启动从属服务器，这无疑比仅在单台机器上运行计数查询要慢。

这是我 2013 年的两便士。

Answer 17

在某个列上放置一个索引。这应该允许优化器对索引块执行完全扫描，而不是对表进行完全扫描。这将大大降低您的 IO 成本。看前后的执行计划。然后双向测量挂钟时间。

Answer 18

我远不像其他回答过的人那样专家，但我在使用从表中选择随机行的过程（不是过度相关）时遇到问题，但我需要知道其中的行数我的参考表来计算随机指数。使用传统的 Count(*) 或 Count(1) 工作，但我偶尔会获得长达 2 秒的查询运行时间。因此，我使用的是（对于名为“tbl_HighOrder”的表）：

Declare @max int

Select @max = Row_Count
From sys.dm_db_partition_stats
Where Object_Name(Object_Id) = 'tbl_HighOrder'

它运行良好，在 Management Studio 中的查询时间为零。

Answer 19

不完全是与 DBMS 无关的解决方案，但至少您的客户端代码不会看到差异...

创建另一个只有一行和一个整数字段 N¹ 的表 T，并创建只执行的 INSERT TRIGGER：

UPDATE T SET N = N + 1

还创建一个执行的 DELETE TRIGGER：

UPDATE T SET N = N - 1

一个称职的 DBMS 将保证上述操作的原子性²，并且 N 将始终包含准确的行数，然后超级快速简单地获得：

SELECT N FROM T

虽然触发器是特定于 DBMS 的，但从 T 中选择不是，并且您的客户端代码不需要针对每个受支持的 DBMS 进行更改。

但是，如果表是 INSERT 或 DELETE 密集型的，尤其是在 INSERT/DELETE 之后没有立即 COMMIT 时，这可能会产生一些可伸缩性问题。

---

¹ 这些名称只是占位符 - 在生产中使用更有意义的名称。

² 即读写 N 之间的并发事务不能更改 N，只要读写都在单个 SQL 语句中完成。

Answer 20

到目前为止，在 MySQL 上最快的方法是：

SHOW TABLE STATUS;

如果需要，您将立即获得所有表格以及行数（即总数）以及大量额外信息。

Answer 21

我用

select /*+ parallel(a) */  count(1) from table_name a;

Answer 22

有没有更好的方法来获取表格行数的精确计数？

为了简单地回答您的问题，否。

如果您需要独立于 DBMS 的方式来执行此操作，最快的方式始终是：

SELECT COUNT(*) FROM TableName

一些 DBMS 供应商可能有更快的方法，这些方法只适用于他们的系统。其中一些选项已经发布在其他答案中。

COUNT(*) 无论如何都应该由 DBMS 优化（至少任何值得生产的数据库），所以不要试图绕过他们的优化。

附注：
我敢肯定，由于您的表大小，您的许多其他查询也需要很长时间才能完成。任何性能问题都应该通过考虑速度来考虑您的模式设计来解决。我意识到您说过这不是一种改变的选择，但事实证明 10 分钟以上的查询也不是一种选择。当您需要速度时，第 3 次 NF 并不总是最好的方法，有时如果记录没有必须存储在一起，则可以将数据分区到多个表中。想一想……

Answer 23

我不认为有一个通用的总是最快的解决方案：一些 RDBMS/版本对SELECT COUNT(*) 进行了特定的优化，使用更快的选项，而其他的只是表扫描。您需要访问第二组的文档/支持站点，这可能需要编写一些更具体的查询，通常是以某种方式命中索引的查询。

编辑：

根据您的架构和数据分布，这里有一个可能可行的想法：您是否有一个索引列引用一个递增的值、一个数字递增的 ID，例如，甚至是时间戳或日期？然后，假设没有发生删除，应该可以将计数存储到某个最近的值（昨天的日期，最近某个采样点的最高 ID 值）并添加除此之外的计数，这应该在索引中很快解决.当然，非常依赖于值和索引，但几乎适用于任何 DBMS 的任何版本。

Answer 24

如果 SQL Server 版本是 2005/2008，则可以使用 DMV 计算表中的行数：

-- Shows all user tables and row counts for the current database 
-- Remove is_ms_shipped = 0 check to include system objects 
-- i.index_id < 2 indicates clustered index (1) or hash table (0) 
SELECT o.name, 
 ddps.row_count 
FROM sys.indexes AS i 
 INNER JOIN sys.objects AS o ON i.OBJECT_ID = o.OBJECT_ID 
 INNER JOIN sys.dm_db_partition_stats AS ddps ON i.OBJECT_ID = ddps.OBJECT_ID 
 AND i.index_id = ddps.index_id 
WHERE i.index_id < 2 
 AND o.is_ms_shipped = 0 
ORDER BY o.NAME 

对于 SQL Server 2000 数据库引擎，sysindexes 可以工作，但强烈建议避免在 SQL Server 的未来版本中使用它，因为它可能会在不久的将来被删除。

示例代码取自：How To Get Table Row Counts Quickly And Painlessly

Answer 25

我遇到过一些文章指出当表有很多行和很多列时，SELECT COUNT(*) FROM TABLE_NAME 会很慢。

这取决于数据库。一些加速计数，例如通过跟踪索引中的行是活的还是死的，允许仅索引扫描以提取行数。其他人则没有，因此需要访问整个表并一一计算活动行数。对于一张巨大的桌子来说，这两种方法都会很慢。

请注意，您通常可以使用查询优化工具、表统计信息等来提取一个好的估计值。例如，在 PostgreSQL 的情况下，您可以解析 explain count(*) from yourtable 的输出并得到一个相当好的估计值的行。这让我想到了你的第二个问题。

我有一个可能包含数十亿行的表 [它大约有 15 列]。有没有更好的方法来获取表格行数的精确计数？

真的吗？ :-) 您真​​的是指具有数十亿行的表中的 exact 计数吗？你真的确定吗？ :-)

如果您真的这样做，您可以使用触发器跟踪总数，但如果这样做，请注意并发和死锁。

Answer 26

你可以试试这个sp_spaceused (Transact-SQL)

显示行数，磁盘 保留空间，以及使用的磁盘空间 表、索引视图或服务 当前数据库中的代理队列， 或显示保留的磁盘空间 并被整个数据库使用。