我们有一个带有表的数据库，该表的值是从另一个系统导入的。有一个自动增量列，没有重复的值，但缺少值。例如，运行以下查询：

select count(id) from arrc_vouchers where id between 1 and 100

应该返回100，但返回87。我可以运行任何查询来返回缺失数字的值吗？例如，可能存在ID为1-70和83-100的记录，但是没有ID为71-82的记录。我想返回71、72、73等。

这可能吗？

更新资料

ConfexianMJS 在性能方面提供了更好的 答案。

（不尽快）的答案

以下版本适用于任何大小的表格（不仅限于100行）：

SELECT (t1.id + 1) as gap_starts_at, 
       (SELECT MIN(t3.id) -1 FROM arrc_vouchers t3 WHERE t3.id > t1.id) as gap_ends_at
FROM arrc_vouchers t1
WHERE NOT EXISTS (SELECT t2.id FROM arrc_vouchers t2 WHERE t2.id = t1.id + 1)
HAVING gap_ends_at IS NOT NULL

• gap_starts_at -当前差距的第一个ID
• gap_ends_at -当前间隙中的最后一个ID

这对我来说很有效，可以找到表中包含超过8万行的空白：

SELECT
 CONCAT(z.expected, IF(z.got-1>z.expected, CONCAT(' thru ',z.got-1), '')) AS missing
FROM (
 SELECT
  @rownum:=@rownum+1 AS expected,
  IF(@rownum=YourCol, 0, @rownum:=YourCol) AS got
 FROM
  (SELECT @rownum:=0) AS a
  JOIN YourTable
  ORDER BY YourCol
 ) AS z
WHERE z.got!=0;

结果：

+------------------+
| missing          |
+------------------+
| 1 thru 99        |
| 666 thru 667     |
| 50000            |
| 66419 thru 66456 |
+------------------+
4 rows in set (0.06 sec)

请注意，列expected和got至关重要。

如果您知道YourCol它不是从1开始并且没关系，则可以替换

(SELECT @rownum:=0) AS a

与

(SELECT @rownum:=(SELECT MIN(YourCol)-1 FROM YourTable)) AS a

新结果：

+------------------+
| missing          |
+------------------+
| 666 thru 667     |
| 50000            |
| 66419 thru 66456 |
+------------------+
3 rows in set (0.06 sec)

如果您需要对丢失的ID执行某种shell脚本任务，则也可以使用此变体以便直接生成可以在bash中迭代的表达式。

SELECT GROUP_CONCAT(IF(z.got-1>z.expected, CONCAT('$(',z.expected,' ',z.got-1,')'), z.expected) SEPARATOR " ") AS missing
FROM (  SELECT   @rownum:=@rownum+1 AS expected,   IF(@rownum=height, 0, @rownum:=height) AS got  FROM   (SELECT @rownum:=0) AS a   JOIN block   ORDER BY height  ) AS z WHERE z.got!=0;

产生这样的输出

$(seq 1 99) $(seq 666 667) 50000 $(seq 66419 66456)

然后，您可以将其复制并粘贴到bash终端的for循环中，以对每个ID执行命令

for ID in $(seq 1 99) $(seq 666 667) 50000 $(seq 66419 66456); do
  echo $ID
  # fill the gaps
done

与上面相同，只是可读性和可执行性均相同。通过更改上面的“ CONCAT”命令，可以为其他编程语言生成语法。甚至SQL。

快速和肮脏的查询应该可以解决问题：

SELECT a AS id, b AS next_id, (b - a) -1 AS missing_inbetween
FROM 
 (
SELECT a1.id AS a , MIN(a2.id) AS b 
FROM arrc_vouchers  AS a1
LEFT JOIN arrc_vouchers AS a2 ON a2.id > a1.id
WHERE a1.id <= 100
GROUP BY a1.id
) AS tab

WHERE 
b > a + 1

这将为您提供一张表格，显示上面缺少ID的ID和存在的next_id，以及之间缺少多少个...

 
id next_id missing_inbetween
 1 4 2
68 70 1
75 87 11

如果您使用，MariaDB则可以使用序列存储引擎更快（800％）的选择：

SELECT * FROM seq_1_to_50000 WHERE SEQ NOT IN (SELECT COL FROM TABLE);

创建一个包含100行和一个包含值1-100的单列的临时表。

外部将此表连接到arrc_vouchers表，并选择arrc_vouchers id为null的单列值。

对这个盲人进行编码，但应该可以。

select tempid from temptable 
left join arrc_vouchers on temptable.tempid = arrc_vouchers.id 
where arrc_vouchers.id is null

需要查询+一些代码进行某些处理的替代解决方案是：

select l.id lValue, c.id cValue, r.id rValue 
  from 
  arrc_vouchers l 
  right join arrc_vouchers c on l.id=IF(c.id > 0, c.id-1, null)
  left  join arrc_vouchers r on r.id=c.id+1
where 1=1
  and c.id > 0 
  and (l.id is null or r.id is null)
order by c.id asc;

请注意，该查询不包含任何子选择，我们知道该子选择没有被MySQL的计划者有效地处理。

这将为每个CentralValue（cValue）返回一个没有较小值（lValue）或较大值（rValue）的条目，即：

lValue |cValue|rValue
-------+------+-------
{null} | 2    | 3      
8      | 9    | {null} 
{null} | 22   | 23     
23     | 24   | {null} 
{null} | 29   | {null} 
{null} | 33   | {null} 

无需进一步说明（我们将在下面的段落中看到），此输出表示：

• 0到2之间没有值
• 9至22之间没有值
• 24至29之间没有值
• 29至33之间没有值
• 介于33和MAX VALUE之间的值

因此，基本思想是对同一张表进行RIGHT和LEFT连接，看每个值是否有相邻值（即：如果中心值是'3'，那么我们在左边检查3-1 = 2并在3 + 1处检查右），并且当ROW在RIGHT或LEFT处具有NULL值时，我们知道没有相邻的值。

我的表的完整原始输出是：

select * from arrc_vouchers order by id asc;

0  
2  
3  
4  
5  
6  
7  
8  
9  
22 
23 
24 
29 
33 

一些注意事项：

1. 如果将“ id”字段定义为UNSIGNED，则需要使用联接条件中的SQL IF语句，因此不允许将其减小到零以下。如果您将c.value>保持为下一个注释中所述的值，那么这并不是绝对必要的，但是我将它作为doc包含在内。
2. 我正在过滤零中心值，因为我们对任何先前的值都不感兴趣，因此我们可以从下一行获取发布值。

如果序列中两个数字之间的间隔最大为1（例如1,3,5,6），则可以使用的查询为：

select s.id+1 from source1 s where s.id+1 not in(select id from source1) and s.id+1<(select max(id) from source1);

• table_name- source1
• column_name- id

根据Lucek上面给出的答案，此存储过程使您可以指定要测试以查找非连续记录的表和列名称-从而回答了原始问题，还演示了如何使用@var表示表＆ /或存储过程中的列。

create definer=`root`@`localhost` procedure `spfindnoncontiguous`(in `param_tbl` varchar(64), in `param_col` varchar(64))
language sql
not deterministic
contains sql
sql security definer
comment ''
begin
declare strsql varchar(1000);
declare tbl varchar(64);
declare col varchar(64);

set @tbl=cast(param_tbl as char character set utf8);
set @col=cast(param_col as char character set utf8);

set @strsql=concat("select 
    ( t1.",@col," + 1 ) as starts_at, 
  ( select min(t3.",@col,") -1 from ",@tbl," t3 where t3.",@col," > t1.",@col," ) as ends_at
    from ",@tbl," t1
        where not exists ( select t2.",@col," from ",@tbl," t2 where t2.",@col," = t1.",@col," + 1 )
        having ends_at is not null");

prepare stmt from @strsql;
execute stmt;
deallocate prepare stmt;
end

我以不同的方式进行了尝试，发现的最佳性能是以下简单查询：

select a.id+1 gapIni
    ,(select x.id-1 from arrc_vouchers x where x.id>a.id+1 limit 1) gapEnd
    from arrc_vouchers a
    left join arrc_vouchers b on b.id=a.id+1
    where b.id is null
    order by 1
;

...一个左联接检查下一个ID是否存在，只有在找不到下一个ID的情况下，子查询才能找到存在的下一个ID以查找间隙的末尾。我这样做是因为使用等于（=）的查询比大于（>）运算符的性能更好。

使用sqlfiddle，它不会显示其他查询的不同性能，但是在实际数据库中，该查询的结果比其他查询快3倍。

模式：

CREATE TABLE arrc_vouchers (id int primary key)
;
INSERT INTO `arrc_vouchers` (`id`) VALUES (1),(4),(5),(7),(8),(9),(10),(11),(15),(16),(17),(18),(19),(20),(21),(22),(23),(24),(25),(26),(27),(28),(29)
;

按照下面的所有查询来比较性能：

select a.id+1 gapIni
    ,(select x.id-1 from arrc_vouchers x where x.id>a.id+1 limit 1) gapEnd
    from arrc_vouchers a
    left join arrc_vouchers b on b.id=a.id+1
    where b.id is null
    order by 1
;
select *, (gapEnd-gapIni) qt
    from (
        select id+1 gapIni
        ,(select x.id from arrc_vouchers x where x.id>a.id limit 1) gapEnd
        from arrc_vouchers a
        order by id
    ) a where gapEnd <> gapIni
;
select id+1 gapIni
    ,(select x.id from arrc_vouchers x where x.id>a.id limit 1) gapEnd
    #,coalesce((select id from arrc_vouchers x where x.id=a.id+1),(select x.id from arrc_vouchers x where x.id>a.id limit 1)) gapEnd
    from arrc_vouchers a
    where id+1 <> (select x.id from arrc_vouchers x where x.id>a.id limit 1)
    order by id
;
select id+1 gapIni
    ,coalesce((select id from arrc_vouchers x where x.id=a.id+1),(select x.id from arrc_vouchers x where x.id>a.id limit 1)) gapEnd
    from arrc_vouchers a
    order by id
;
select id+1 gapIni
    ,coalesce((select id from arrc_vouchers x where x.id=a.id+1),concat('*** GAT *** ',(select x.id from arrc_vouchers x where x.id>a.id limit 1))) gapEnd
    from arrc_vouchers a
    order by id
;

也许它对某人有用并且有用。

您可以使用以下sqlfiddle查看和测试我的查询：

http://sqlfiddle.com/#!9/6bdca7/1

尽管所有这些似乎都有效，但是当有50,000条记录时，结果集将在很长的时间内返回。

我使用了它，它找到间隔或下一个可用的（最近使用+ 1），并且从查询中返回的速度更快。

SELECT a.id as beforegap, a.id+1 as avail
FROM table_name a
where (select b.id from table_name b where b.id=a.id+1) is null
limit 1;

可能不相关，但是我一直在寻找类似的内容，以便按数字顺序列出差距，并找到了这篇文章，根据您的实际需求提供了多种不同的解决方案。我一直在寻找序列中的第一个可用间隔（即下一个可用数字），这似乎很好。

SELECT MIN（l.number_sequence + 1）作为下一个对l.number_sequence + 1 = r.number_sequence的患者在l.number_sequence上为r。从2005年开始，这里讨论了其他几种方案和解决方案！

如何使用SQL查找序列中的缺失值