Come trovo un "gap" nel contatore di corsa con SQL?

Question

Mi piacerebbe trovare il primo "spazio" in una colonna contatore in una tabella SQL. Ad esempio, se ci sono i valori 1,2,4 e 5, vorrei scoprire 3.

Posso ovviamente ottenere i valori in ordine e analizzarlo manualmente, ma mi piacerebbe sapere se ci sarebbe un modo per farlo in SQL.

Inoltre, dovrebbe essere SQL abbastanza standard, che funziona con diversi DBMS.

Answer 1

Nel MySQL e PostgreSQL:

SELECT id + 1 
FROM mytable mo 
WHERE NOT EXISTS 
     (
     SELECT NULL 
     FROM mytable mi 
     WHERE mi.id = mo.id + 1 
     ) 
ORDER BY 
     id 
LIMIT 1 

In SQL Server:

SELECT TOP 1 
     id + 1 
FROM mytable mo 
WHERE NOT EXISTS 
     (
     SELECT NULL 
     FROM mytable mi 
     WHERE mi.id = mo.id + 1 
     ) 
ORDER BY 
     id 

In Oracle:

SELECT * 
FROM (
     SELECT id + 1 AS gap 
     FROM mytable mo 
     WHERE NOT EXISTS 
       (
       SELECT NULL 
       FROM mytable mi 
       WHERE mi.id = mo.id + 1 
       ) 
     ORDER BY 
       id 
     ) 
WHERE rownum = 1 

ANSI (funziona ovunque, efficienza minima):

SELECT MIN(id) + 1 
FROM mytable mo 
WHERE NOT EXISTS 
     (
     SELECT NULL 
     FROM mytable mi 
     WHERE mi.id = mo.id + 1 
     ) 

sistemi di supporto scorrevoli funzioni finestra:

SELECT -- TOP 1 
     -- Uncomment above for SQL Server 2012+ 
     previd 
FROM (
     SELECT id, 
       LAG(id) OVER (ORDER BY id) previd 
     FROM mytable 
     ) q 
WHERE previd <> id - 1 
ORDER BY 
     id 
-- LIMIT 1 
-- Uncomment above for PostgreSQL 

Answer 2

La prima cosa che mi è venuta in mente. Non sono sicuro se sia una buona idea andare in questo modo, ma dovrebbe funzionare. Supponiamo che la tabella è t e la colonna è c:

SELECT t1.c+1 AS gap FROM t as t1 LEFT OUTER JOIN t as t2 ON (t1.c+1=t2.c) WHERE t2.c IS NULL ORDER BY gap ASC LIMIT 1

Edit: Questo potrebbe essere un segno di spunta più veloce (e più breve!):

SELECT min(t1.c)+1 AS gap FROM t as t1 LEFT OUTER JOIN t as t2 ON (t1.c+1=t2.c) WHERE t2.c IS NULL

Answer 3

Questo funziona in SQL Server - non possono provarlo in altri sistemi, ma sembra normale ...

SELECT MIN(t1.ID)+1 FROM mytable t1 WHERE NOT EXISTS (SELECT ID FROM mytable WHERE ID = (t1.ID + 1)) 

Si potrebbe anche aggiungere un punto di partenza alla clausola in cui ...

SELECT MIN(t1.ID)+1 FROM mytable t1 WHERE NOT EXISTS (SELECT ID FROM mytable WHERE ID = (t1.ID + 1)) AND ID > 2000 

Quindi, se tu avessi 2000, 2001, 2002 e 2005, dove 2003 e nel 2004 non esisteva, che sarebbe tornato 2003.

Answer 4

Join interno a una vista o sequenza che ha tutti i valori possibili.

Nessun tavolo? Crea un tavolo. Tengo sempre un tavolo finto solo per questo.

create table artificial_range( 
    id int not null primary key auto_increment, 
    name varchar(20) null) ; 

-- or whatever your database requires for an auto increment column 

insert into artificial_range(name) values (null) 
-- create one row. 

insert into artificial_range(name) select name from artificial_range; 
-- you now have two rows 

insert into artificial_range(name) select name from artificial_range; 
-- you now have four rows 

insert into artificial_range(name) select name from artificial_range; 
-- you now have eight rows 

--etc. 

insert into artificial_range(name) select name from artificial_range; 
-- you now have 1024 rows, with ids 1-1024 

Poi,

select a.id from artificial_range a 
where not exists (select * from your_table b 
where b.counter = a.id) ; 

Answer 5

mia ipotesi:

SELECT MIN(p1.field) + 1 as gap 
FROM table1 AS p1 
INNER JOIN table1 as p3 ON (p1.field = p3.field + 2) 
LEFT OUTER JOIN table1 AS p2 ON (p1.field = p2.field + 1) 
WHERE p2.field is null; 

Answer 6

In realtà non c'è un estremamente modo standard SQL per fare questo, ma con una qualche forma di limitazione clausola di voi può fare

SELECT `table`.`num` + 1 
FROM `table` 
LEFT JOIN `table` AS `alt` 
ON `alt`.`num` = `table`.`num` + 1 
WHERE `alt`.`num` IS NULL 
LIMIT 1 

(MySQL, PostgreSQL)

o

SELECT TOP 1 `num` + 1 
FROM `table` 
LEFT JOIN `table` AS `alt` 
ON `alt`.`num` = `table`.`num` + 1 
WHERE `alt`.`num` IS NULL 

(SQL Server)

o

SELECT `num` + 1 
FROM `table` 
LEFT JOIN `table` AS `alt` 
ON `alt`.`num` = `table`.`num` + 1 
WHERE `alt`.`num` IS NULL 
AND ROWNUM = 1 

(Oracle)

Answer 7

Le risposte tutti funzionano bene se si dispone di un primo valore id = 1, altrimenti questo gap non verrà rilevato. Per esempio, se i valori id tabella sono 3,4,5, le vostre domande torneranno 6.

ho fatto qualcosa di simile

SELECT MIN(ID+1) FROM (
    SELECT 0 AS ID UNION ALL 
    SELECT 
     MIN(ID + 1) 
    FROM  
     TableX) AS T1 
WHERE 
    ID+1 NOT IN (SELECT ID FROM TableX) 

Answer 8

rappresenta Questa è per tutto ciò di cui finora. Include 0 come punto di partenza, che verrà impostato di default se nessun valore esiste. Ho anche aggiunto le posizioni appropriate per le altre parti di una chiave multi-valore. Questo è stato testato solo su SQL Server.

select 
    MIN(ID) 
from (
    select 
     0 ID 
    union all 
    select 
     [YourIdColumn]+1 
    from 
     [YourTable] 
    where 
     --Filter the rest of your key-- 
    ) foo 
left join 
    [YourTable] 
    on [YourIdColumn]=ID 
    and --Filter the rest of your key-- 
where 
    [YourIdColumn] is null 

Answer 9

select min([ColumnName]) from [TableName] 
where [ColumnName]-1 not in (select [ColumnName] from [TableName]) 
and [ColumnName] <> (select min([ColumnName]) from [TableName]) 

Answer 10

Per PostgreSQL

Un esempio che fa uso di query ricorsiva.

Questo potrebbe essere utile se si vuole trovare un varco in un intervallo specifico (che funzionerà anche se la tabella è vuota, mentre gli altri esempi non)

WITH  
    RECURSIVE a(id) AS (VALUES (1) UNION ALL SELECT id + 1 FROM a WHERE id < 100), -- range 1..100 
    b AS (SELECT id FROM my_table) -- your table ID list  
SELECT a.id -- find numbers from the range that do not exist in main table 
FROM a 
LEFT JOIN b ON b.id = a.id 
WHERE b.id IS NULL 
-- LIMIT 1 -- uncomment if only the first value is needed 

Answer 11

Ecco standard di uno SQL soluzione che funziona su tutti i server di database senza modifiche:

select min(counter + 1) FIRST_GAP 
    from my_table a 
    where not exists (select 'x' from my_table b where b.counter = a.counter + 1) 
     and a.counter <> (select max(c.counter) from my_table c); 

Vedere in azione per;

• PL/SQL tramite Oracle's livesql,
• MySQL via sqlfiddle,
• PostgreSQL tramite sqlfiddle
• MS SQL tramite sqlfiddle

Answer 12

Funziona per tavoli vuoti o con valori negativi pure.Appena testato in SQL Server 2012

select min(n) from (
select case when lead(i,1,0) over(order by i)>i+1 then i+1 else null end n from MyTable) w 

Answer 13

Se il licenziatario utilizza Firebird 3 questo è più elegante e semplice:

select RowID 
    from (
    select `ID_Column`, Row_Number() over(order by `ID_Column`) as RowID 
     from `Your_Table` 
     order by `ID_Column`) 
    where `ID_Column` <> RowID 
    rows 1