Requête SQL pour trouver les numéros de séquence manquants
J'ai une colonne nommée sequence. Les données de cette colonne ressemblent à 1, 2, 3, 4, 5, 7, 9, 10, 15.
Je dois trouver les numéros de séquence manquants dans le tableau. Quelle requête SQL trouvera les numéros de séquence manquants dans ma table? J'attends des résultats comme
Missing numbers
---------------
6
8
11
12
13
14
J'utilise une seule table. J'ai essayé la requête ci-dessous, mais je n'obtiens pas les résultats souhaités.
select de.sequence + 1 as sequence from dataentry as de
left outer join dataentry as de1 on de.sequence + 1 = de1.sequence
where de1.sequence is null order by sequence asc;
Que diriez-vous de quelque chose comme:
select (select isnull(max(val)+1,1) from mydata where val < md.val) as [from],
md.val - 1 as [to]
from mydata md
where md.val != 1 and not exists (
select 1 from mydata md2 where md2.val = md.val - 1)
donnant des résultats résumés:
from to
----------- -----------
6 6
8 8
11 14
Je sais que c'est un article très ancien, mais je voulais ajouter cette solution que j'ai trouvée ICI afin de la trouver plus facilement:
WITH Missing (missnum, maxid)
AS
(
SELECT 1 AS missnum, (select max(id) from @TT)
UNION ALL
SELECT missnum + 1, maxid FROM Missing
WHERE missnum < maxid
)
SELECT missnum
FROM Missing
LEFT OUTER JOIN @TT tt on tt.id = Missing.missnum
WHERE tt.id is NULL
OPTION (MAXRECURSION 0);
Essayez avec ceci:
declare @min int
declare @max int
select @min = min(seq_field), @max = max(seq_field) from [Table]
create table #tmp (Field_No int)
while @min <= @max
begin
if not exists (select * from [Table] where seq_field = @min)
insert into #tmp (Field_No) values (@min)
set @min = @min + 1
end
select * from #tmp
drop table #tmp
Les meilleures solutions sont celles qui utilisent une table temporaire avec la séquence. En supposant que vous construisiez une telle table, LEFT JOIN avec la vérification NULL devrait faire l'affaire:
SELECT #sequence.value
FROM #sequence
LEFT JOIN MyTable ON #sequence.value = MyTable.value
WHERE MyTable.value IS NULL
Mais si vous devez répéter cette opération souvent (et plus alors pour 1 séquence dans la base de données), je créerais une table "données statiques" et disposerais d'un script pour la remplir au MAX (valeur) de toutes les tables dont vous avez besoin .
Voici un script pour créer une procédure stockée qui renvoie les numéros séquentiels manquants pour une plage de dates donnée.
CREATE PROCEDURE dbo.ddc_RolledBackOrders
-- Add the parameters for the stored procedure here
@StartDate DATETIME ,
@EndDate DATETIME
AS
BEGIN
SET NOCOUNT ON;
DECLARE @Min BIGINT
DECLARE @Max BIGINT
DECLARE @i BIGINT
IF OBJECT_ID('tempdb..#TempTable') IS NOT NULL
BEGIN
DROP TABLE #TempTable
END
CREATE TABLE #TempTable
(
TempOrderNumber BIGINT
)
SELECT @Min = ( SELECT MIN(ordernumber)
FROM dbo.Orders WITH ( NOLOCK )
WHERE OrderDate BETWEEN @StartDate AND @EndDate)
SELECT @Max = ( SELECT MAX(ordernumber)
FROM dbo.Orders WITH ( NOLOCK )
WHERE OrderDate BETWEEN @StartDate AND @EndDate)
SELECT @i = @Min
WHILE @i <= @Max
BEGIN
INSERT INTO #TempTable
SELECT @i
SELECT @i = @i + 1
END
SELECT TempOrderNumber
FROM #TempTable
LEFT JOIN dbo.orders o WITH ( NOLOCK ) ON tempordernumber = o.OrderNumber
WHERE o.OrderNumber IS NULL
END
ALLER
-- This will return better Results
-- ----------------------------------
;With CTERange
As (
select (select isnull(max(ArchiveID)+1,1) from tblArchives where ArchiveID < md.ArchiveID) as [from],
md.ArchiveID - 1 as [to]
from tblArchives md
where md.ArchiveID != 1 and not exists (
select 1 from tblArchives md2 where md2.ArchiveID = md.ArchiveID - 1)
) SELECT [from], [to], ([to]-[from])+1 [total missing]
From CTERange
ORDER BY ([to]-[from])+1 DESC;
from to total missing
------- ------- --------------
6 6 1
8 8 1
11 14 4
Juste pour le plaisir, j'ai décidé de poster ma solution.
J'avais une colonne d'identité dans mon tableau et je voulais trouver les numéros de facture manquants. J'ai passé en revue tous les exemples que j'ai pu trouver mais ils n'étaient pas assez élégants.
CREATE VIEW EENSkippedInvoicveNo
AS
SELECT CASE WHEN MSCNT = 1 THEN CAST(MSFIRST AS VARCHAR (8)) ELSE
CAST(MSFIRST AS VARCHAR (8)) + ' - ' + CAST(MSlAST AS VARCHAR (8)) END AS MISSING,
MSCNT, INV_DT FROM (
select invNo+1 as Msfirst, inv_no -1 as Mslast, inv_no - invno -1 as msCnt, dbo.fmtdt(Inv_dt) AS INV_dT
from (select inv_no as invNo, a4glidentity + 1 as a4glid
from oehdrhst_sql where inv_dt > 20140401) as s
inner Join oehdrhst_sql as h
on a4glid = a4glidentity
where inv_no - invno <> 1
) AS SS
DECLARE @MaxID INT = (SELECT MAX(timerecordid) FROM dbo.TimeRecord)
SELECT SeqID AS MissingSeqID
FROM (SELECT ROW_NUMBER() OVER (ORDER BY column_id) SeqID from sys.columns) LkUp
LEFT JOIN dbo.TimeRecord t ON t.timeRecordId = LkUp.SeqID
WHERE t.timeRecordId is null and SeqID < @MaxID
J'ai trouvé cette réponse ici: http://sql-developers.blogspot.com/2012/10/how-to-find-missing-identitysequence.html
Je cherchais une solution et ai trouvé de nombreuses réponses. C'est celle que j'ai utilisée et cela a très bien fonctionné. J'espère que cela aidera tous ceux qui cherchent une réponse similaire.
Ceci est mon interprétation de ce problème, en plaçant le contenu dans une variable de table à laquelle je peux facilement accéder dans le reste de mon script.
DECLARE @IDS TABLE (row int, ID int)
INSERT INTO @IDS
select ROW_NUMBER() OVER (ORDER BY x.[Referred_ID]), x.[Referred_ID] FROM
(SELECT b.[Referred_ID] + 1 [Referred_ID]
FROM [catalog].[dbo].[Referrals] b) as x
LEFT JOIN [catalog].[dbo].[Referrals] a ON x.[Referred_ID] = a.[Referred_ID]
WHERE a.[Referred_ID] IS NULL
select * from @IDS
SELECT CASE WHEN MAX(column_name) = COUNT(*)
THEN CAST(NULL AS INTEGER)
-- THEN MAX(column_name) + 1 as other option
WHEN MIN(column_name) > 1
THEN 1
WHEN MAX(column_name) <> COUNT(*)
THEN (SELECT MIN(column_name)+1
FROM table_name
WHERE (column_name+ 1)
NOT IN (SELECT column_name FROM table_name))
ELSE NULL END
FROM table_name;
Vous pouvez également résoudre le problème en utilisant quelque chose comme un CTE pour générer la séquence complète:
create table #tmp (sequence int) insérer dans #tmp (séquence) valeurs (1) insérer dans #tmp (séquence) valeurs (2) insérer dans #tmp ( séquence) valeurs (3) insérer dans #tmp (séquence) valeurs (5) insérer dans #tmp (séquence) valeurs (6) insérer dans #tmp (séquence) valeurs (8) insert dans #tmp (séquence) valeurs (10) insérer dans #tmp (séquence) valeurs (11) insérer dans #tmp (séquence) valeurs (14)
DECLARE @max INT
SELECT @max = max(sequence) from #tmp;
with full_sequence
(
Sequence
)
as
(
SELECT 1 Sequence
UNION ALL
SELECT Sequence + 1
FROM full_sequence
WHERE Sequence < @max
)
SELECT
full_sequence.sequence
FROM
full_sequence
LEFT JOIN
#tmp
ON
full_sequence.sequence = #tmp.sequence
WHERE
#tmp.sequence IS NULL
Hmmmm - le formatage ne fonctionne pas ici pour une raison quelconque? Quelqu'un peut-il voir le problème?
Toutes les solutions données ne sont-elles pas trop complexes? Ne serait-ce pas beaucoup plus simple:
SELECT *
FROM (SELECT row_number() over(order by number) as N from master..spt_values) t
where N not in (select 1 as sequence union
select 2 union
select 3 union
select 4 union
select 5 union
select 7 union
select 10 union
select 15
)
DECLARE @TempSujith TABLE
(MissingId int)
Declare @Id Int
DECLARE @mycur CURSOR
SET @mycur = CURSOR FOR Select Id From tbl_Table
OPEN @mycur
FETCH NEXT FROM @mycur INTO @Id
Declare @index int
Set @index = 1
WHILE @@FETCH_STATUS = 0
BEGIN
if (@index < @Id)
begin
while @index < @Id
begin
insert into @TempSujith values (@index)
set @index = @index + 1
end
end
set @index = @index + 1
FETCH NEXT FROM @mycur INTO @Id
END
Select Id from tbl_Table
select MissingId from @TempSujith
Créer un utile table de pointage :
-- can go up to 4 million or 2^22
select top 100000 identity(int, 1, 1) Id
into Tally
from master..spt_values
cross join master..spt_values
Indexez-le ou indiquez PK ..__ dans cette colonne, puis utilisez EXCEPT pour obtenir votre numéro manquant.
select Id from Tally where Id <= (select max(Id) from TestTable)
except
select Id from TestTable