У нас есть база данных с таблицей, значения которой были импортированы из другой системы. Есть столбец с автоинкрементом, нет повторяющихся значений, но есть пропущенные значения. Например, при выполнении этого запроса:

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

должен вернуть 100, но вместо этого возвращает 87. Могу ли я выполнить какой-либо запрос, который вернет значения отсутствующих чисел? Например, записи могут существовать для идентификаторов 1-70 и 83-100, но отсутствуют записи с идентификаторами 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 в текущем промежутке

Это помогло мне найти пробелы в таблице с более чем 80 тыс. Строк:

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)

Если вам нужно выполнить какую-то задачу сценария оболочки с отсутствующими идентификаторами, вы также можете использовать этот вариант, чтобы напрямую создать выражение, которое вы можете перебирать в 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)

Затем вы можете скопировать и вставить его в цикл for в терминале bash, чтобы выполнить команду для каждого идентификатора.

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

Это даст вам таблицу, показывающую идентификатор, над которым отсутствуют идентификаторы, и 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 равен нулю.

Кодирование это вслепую, но должно работать.

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 эффективно.

Это вернет одну запись на центральное значение (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 в right), а когда ROW имеет значение NULL в RIGHT или LEFT, мы знаем, что смежного значения нет.

Полный необработанный вывод моей таблицы:

select * from arrc_vouchers order by id asc;

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

Некоторые примечания:

1. Оператор SQL IF в условии соединения необходим, если вы определяете поле id как UNSIGNED, поэтому он не позволит вам уменьшить его до нуля. В этом нет строгой необходимости, если вы сохраняете c.value> 0, как указано в следующем примечании, но я включаю его просто как документ.
2. Я фильтрую нулевое центральное значение, так как нас не интересует какое-либо предыдущее значение, и мы можем получить значение сообщения из следующей строки.

Если существует последовательность, в которой между двумя числами пробел не превышает единицы (например, 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
• имя_столбца - id

на основе ответа, приведенного выше Лучеком, эта хранимая процедура позволяет вам указать имена таблиц и столбцов, которые вы хотите протестировать, чтобы найти несмежные записи - таким образом, отвечая на исходный вопрос, а также демонстрируя, как можно использовать @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
;

... одно левое соединение, чтобы проверить, существует ли следующий идентификатор , только если следующий, если не найден, тогда подзапрос находит следующий идентификатор, который существует, чтобы найти конец пробела. Я сделал это, потому что запрос с равным (=) имеет лучшую производительность, чем оператор больше (>).

Используя 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;

Возможно, это не актуально, но я искал что-то вроде этого, чтобы перечислить пробелы в последовательности чисел, и нашел этот пост, в котором есть несколько разных решений в зависимости от того, что именно вы ищете. Я искал первый доступный пробел в последовательности (то есть следующий доступный номер), и, похоже, это работает нормально.

ВЫБЕРИТЕ MIN (l.number_sequence + 1) как nextavabile из пациентов как l LEFT OUTER JOIN пациентов как r на l.number_sequence + 1 = r.number_sequence ГДЕ r.number_sequence имеет значение NULL. Там обсуждались еще несколько сценариев и решений, начиная с 2005 года!

Как найти пропущенные значения в последовательности с помощью SQL