SQL के साथ काउंटर चलाने में मुझे "गैप" कैसे मिलता है?

Question

मैं एसक्यूएल टेबल में एक काउंटर कॉलम में पहला "गैप" खोजना चाहता हूं। उदाहरण के लिए, यदि 1,2,4 और 5 मान हैं, तो मुझे 3 का पता लगाना है।

मैं निश्चित रूप से मूल्यों को प्राप्त कर सकता हूं और मैन्युअल रूप से इसके माध्यम से जा सकता हूं, लेकिन मैं यह जानना चाहूंगा कि क्या एसक्यूएल में ऐसा करने का कोई तरीका होगा।

इसके अलावा, यह काफी मानक SQL होना चाहिए, जो विभिन्न DBMSes के साथ काम कर रहा है।

Comments

Sql सर्वर 2008 और ऊपर आप क्लॉज के LAG(id, 1, null)साथ फ़ंक्शन का उपयोग कर सकते हैं OVER (ORDER BY id)।

— अंजह

Answer 1

में MySQLऔर 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

में 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

में 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 (हर जगह काम करता है, कम से कम कुशल):

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

स्लाइडिंग विंडो फ़ंक्शंस का समर्थन करने वाले सिस्टम:

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

Comments

@vulkanino: कृपया उनसे मांगपत्र को संरक्षित करने के लिए कहें। कृपया यह भी ध्यान दें कि रचनात्मक कॉमन्स लाइसेंस के लिए आपको मेरे निक और प्रश्न के URLसाथ ही टैटू की आवश्यकता होती है , हालांकि यह क्यूआर कोडित हो सकता है जो मुझे लगता है।

— क्वासोई

यह बहुत अच्छा है, लेकिन अगर मेरे पास था [1, 2, 11, 12], तो यह केवल मिल जाएगा 3। मुझे यह पसंद है कि इसके बजाय 3-10 मिलेंगे - मूल रूप से हर अंतराल की शुरुआत और अंत। मैं समझता हूं कि मुझे अपनी खुद की पाइथन स्क्रिप्ट लिखनी पड़ सकती है जो एसक्यूएल का लाभ उठाती है (मेरे मामले में MySql), लेकिन यह अच्छा होगा यदि एसक्यूएल मुझे जो चाहे उसके करीब ला सके (मेरे पास 2 मिलियन पंक्तियों वाली एक तालिका है जिसमें अंतराल है इसलिए मुझे इसे छोटे टुकड़ों में टुकड़ा करने और इस पर कुछ एसक्यूएल चलाने की आवश्यकता होगी)। मुझे लगता है कि मैं एक अंतर की शुरुआत खोजने के लिए एक क्वेरी चला सकता हूं, फिर एक अंतर का अंत खोजने के लिए दूसरा, और वे दो अनुक्रमों को "मर्ज करें" कर सकते हैं।

— हमीश ग्रुबीजन

@ HamishGrubijan: कृपया इसे एक और प्रश्न के रूप में पोस्ट करें

— क्वासोई

@ मल्कोकोग्लू: आप प्राप्त करेंगे NULL, नहीं 0, यदि तालिका खाली है। यह सभी डेटाबेस के लिए सही है।

— क्वासोई

इससे शुरुआती अंतराल ठीक से नहीं मिलेंगे। अगर आपके पास 3,4,5,6,8 है। यह कोड 7 की रिपोर्ट करेगा, क्योंकि इसमें NO 1 भी है। इसलिए यदि आप शुरुआती संख्या याद कर रहे हैं तो आपको उसके लिए जाँच करनी होगी।

— ttomsen

Answer 2

यदि आपके पास पहले मान id = 1 है, तो आपके उत्तर सभी ठीक काम करते हैं, अन्यथा इस अंतर का पता नहीं चलेगा। उदाहरण के लिए यदि आपकी टेबल आईडी का मूल्य 3,4,5 है, तो आपकी क्वेरी 6 वापस आ जाएगी।

मैंने कुछ इस तरह किया

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) 

Comments

यह पहला गैप ढूंढेगा। यदि आपके पास आईडी 0, 2,3,4 है। जवाब है 1. मैं सबसे बड़े अंतर को खोजने के लिए एक जवाब की तलाश में था। अनुक्रम 0,2,3,4, 100,101,102 है। मैं 4-99 गैप ढूंढना चाहता हूं।

— केमिन झोउ

Answer 3

ऐसा करने के लिए वास्तव में एक अत्यंत मानक SQL तरीका नहीं है, लेकिन कुछ प्रकार के क्लॉज को सीमित करने से आप ऐसा कर सकते हैं

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)

या

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

(एस क्यू एल सर्वर)

या

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

(आकाशवाणी)

Comments

यदि कोई अंतर सीमा है, तो सीमा में केवल पहली पंक्ति आपके पोस्टग्रैड क्वेरी के लिए वापस आ जाएगी।

— जॉन हागलैंड

यह मेरे लिए सबसे अधिक समझ में आता है, एक जॉइन का उपयोग करने से आप अपने TOP मान को बदल सकते हैं, और अधिक अंतर परिणाम दिखा सकते हैं।

— एजे_

धन्यवाद, यह बहुत अच्छी तरह से काम करता है और यदि आप सभी बिंदुओं को देखना चाहते हैं जहां एक अंतर है, तो आप सीमा को हटा सकते हैं।

— mekbib.awoke

Answer 4

पहली बात जो मेरे सिर में आई। यकीन नहीं है कि अगर इस तरह से जाना एक अच्छा विचार है, लेकिन काम करना चाहिए। मान लीजिए कि तालिका है tऔर स्तंभ है 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

संपादित करें: यह एक तेजी से एक टिक हो सकता है (और कम!):

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

Comments

बाईं ओर

— जॉय

नहीं, नहीं, ईमोन, LEFT OUTER JOING t2आपको t2टेबल की आवश्यकता होगी , जो सिर्फ एक उपनाम है।

— माइकल क्रेलिन - हैकर

Answer 5

SQL सर्वर में यह काम करता है - अन्य प्रणालियों में इसका परीक्षण नहीं कर सकता है लेकिन यह मानक लगता है ...

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

आप एक प्रारंभिक बिंदु भी जोड़ सकते हैं, जहां क्लॉज ...

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

इसलिए यदि आपके पास 2000, 2001, 2002 और 2005 है, जहां 2003 और 2004 मौजूद नहीं था, तो यह 2003 में वापस आ जाएगा।

Answer 6

निम्नलिखित समाधान:

• परीक्षण डेटा प्रदान करता है;
• एक आंतरिक क्वेरी जो अन्य अंतराल पैदा करती है; तथा
• यह SQL Server 2012 में काम करता है।

क्रमबद्ध पंक्तियों को क्रमिक रूप से "के साथ " क्लॉज में क्रमांकित किया जाता है और फिर पंक्ति संख्या पर एक आंतरिक जोड़ के साथ दो बार परिणाम का पुन: उपयोग करता है, लेकिन 1 से ऑफसेट करता है ताकि पंक्ति के साथ पंक्ति की तुलना करने से पहले, आईडी की तलाश में अधिक से अधिक अंतराल के साथ 1. अधिक के लिए कहा गया है, लेकिन अधिक व्यापक रूप से लागू है।

create table #ID ( id integer );

insert into #ID values (1),(2),    (4),(5),(6),(7),(8),    (12),(13),(14),(15);

with Source as (
    select
         row_number()over ( order by A.id ) as seq
        ,A.id                               as id
    from #ID as A WITH(NOLOCK)
)
Select top 1 gap_start from (
    Select 
         (J.id+1) as gap_start
        ,(K.id-1) as gap_end
    from       Source as J
    inner join Source as K
    on (J.seq+1) = K.seq
    where (J.id - (K.id-1)) <> 0
) as G

भीतर का प्रश्न पैदा करता है:

gap_start   gap_end

3           3

9           11

बाहरी क्वेरी पैदा करता है:

gap_start

3

Answer 7

आंतरिक एक दृश्य या अनुक्रम में शामिल होता है जिसमें सभी संभव मूल्य होते हैं।

कोई टेबल नहीं? एक टेबल बनाओ। मैं हमेशा सिर्फ इसके लिए एक डमी टेबल रखता हूं।

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

फिर,

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

Answer 8

के लिये PostgreSQL

एक उदाहरण जो पुनरावर्ती क्वेरी का उपयोग करता है।

यह तब उपयोगी हो सकता है जब आप एक विशिष्ट सीमा में अंतर खोजना चाहते हैं (यह तालिका खाली होने पर भी काम करेगा, जबकि अन्य विकल्प नहीं होंगे)

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 9

मेरा अनुमान:

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 10

यह एक अब तक उल्लिखित सब कुछ के लिए खाता है। इसमें शुरुआती बिंदु के रूप में 0 शामिल है, जो कि डिफ़ॉल्ट होगा यदि कोई मान भी मौजूद नहीं है। मैंने एक बहु-मूल्य कुंजी के अन्य भागों के लिए उपयुक्त स्थान भी जोड़े। यह केवल SQL सर्वर पर परीक्षण किया गया है।

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 11

मैंने इसे करने का एक त्वरित तरीका लिखा। यकीन नहीं है कि यह सबसे कुशल है, लेकिन काम हो जाता है। ध्यान दें कि यह आपको अंतराल नहीं बताता है, लेकिन अंतराल के पहले और बाद में आपको आईडी बताता है (ध्यान रखें कि अंतर कई मान हो सकता है, इसलिए उदाहरण के लिए 1,2,4,7,11 आदि)

मैं एक उदाहरण के रूप में sqlite का उपयोग कर रहा हूं

यदि यह आपकी तालिका संरचना है

create table sequential(id int not null, name varchar(10) null);

और ये आपकी पंक्तियाँ हैं

id|name
1|one
2|two
4|four
5|five
9|nine

क्वेरी है

select a.* from sequential a left join sequential b on a.id = b.id + 1 where b.id is null and a.id <> (select min(id) from sequential)
union
select a.* from sequential a left join sequential b on a.id = b.id - 1 where b.id is null and a.id <> (select max(id) from sequential);

https://gist.github.com/wkimeria/7787ffe84d1c54216f1b320996b17b7e

Answer 12

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

Answer 13

यहाँ मानक SQL समाधान है जो बिना किसी परिवर्तन के सभी डेटाबेस सर्वर पर चलता है:

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);

के लिए कार्रवाई में देखें;

• Oracle के जीवनकाल के माध्यम से PL / SQL ,
• MySQL sqlfiddle के माध्यम से ,
• PostgreSQL के माध्यम से sqlfiddle के
• MS Sql sqlfiddle के माध्यम से

Answer 14

यह खाली टेबल के लिए या नकारात्मक मानों के साथ भी काम करता है। SQL सर्वर 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 15

यदि आप Firebird 3 का उपयोग करते हैं तो यह सबसे सुरुचिपूर्ण और सरल है:

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

Answer 16

            -- PUT THE TABLE NAME AND COLUMN NAME BELOW
            -- IN MY EXAMPLE, THE TABLE NAME IS = SHOW_GAPS AND COLUMN NAME IS = ID

            -- PUT THESE TWO VALUES AND EXECUTE THE QUERY

            DECLARE @TABLE_NAME VARCHAR(100) = 'SHOW_GAPS'
            DECLARE @COLUMN_NAME VARCHAR(100) = 'ID'


            DECLARE @SQL VARCHAR(MAX)
            SET @SQL = 
            'SELECT  TOP 1
                    '+@COLUMN_NAME+' + 1
            FROM    '+@TABLE_NAME+' mo
            WHERE   NOT EXISTS
                    (
                    SELECT  NULL
                    FROM    '+@TABLE_NAME+' mi 
                    WHERE   mi.'+@COLUMN_NAME+' = mo.'+@COLUMN_NAME+' + 1
                    )
            ORDER BY
                    '+@COLUMN_NAME

            -- SELECT @SQL

            DECLARE @MISSING_ID TABLE (ID INT)

            INSERT INTO @MISSING_ID
            EXEC (@SQL)

            --select * from @MISSING_ID

            declare @var_for_cursor int
            DECLARE @LOW INT
            DECLARE @HIGH INT
            DECLARE @FINAL_RANGE TABLE (LOWER_MISSING_RANGE INT, HIGHER_MISSING_RANGE INT)
            DECLARE IdentityGapCursor CURSOR FOR   
            select * from @MISSING_ID
            ORDER BY 1;  

            open IdentityGapCursor

            fetch next from IdentityGapCursor
            into @var_for_cursor

            WHILE @@FETCH_STATUS = 0  
            BEGIN
            SET @SQL = '
            DECLARE @LOW INT
            SELECT @LOW = MAX('+@COLUMN_NAME+') + 1 FROM '+@TABLE_NAME
                    +' WHERE '+@COLUMN_NAME+' < ' + cast( @var_for_cursor as VARCHAR(MAX))

            SET @SQL = @sql + '
            DECLARE @HIGH INT
            SELECT @HIGH = MIN('+@COLUMN_NAME+') - 1 FROM '+@TABLE_NAME
                    +' WHERE '+@COLUMN_NAME+' > ' + cast( @var_for_cursor as VARCHAR(MAX))

            SET @SQL = @sql + 'SELECT @LOW,@HIGH'

            INSERT INTO @FINAL_RANGE
             EXEC( @SQL)
            fetch next from IdentityGapCursor
            into @var_for_cursor
            END

            CLOSE IdentityGapCursor;  
            DEALLOCATE IdentityGapCursor;  

            SELECT ROW_NUMBER() OVER(ORDER BY LOWER_MISSING_RANGE) AS 'Gap Number',* FROM @FINAL_RANGE

Answer 17

पाया अधिकांश दृष्टिकोण बहुत धीमी गति से चलते हैं mysql। यहाँ मेरे लिए समाधान है mysql < 8.0। अंत के पास एक अंतर के साथ 1M रिकॉर्ड पर परीक्षण किया ~ खत्म करने के लिए 1sec। यकीन नहीं होता कि यह अन्य एसक्यूएल फ्लेवर पर फिट बैठता है।

SELECT cardNumber - 1
FROM
    (SELECT @row_number := 0) as t,
    (
        SELECT (@row_number:=@row_number+1), cardNumber, cardNumber-@row_number AS diff
        FROM cards
        ORDER BY cardNumber
    ) as x
WHERE diff >= 1
LIMIT 0,1

मुझे लगता है कि अनुक्रम `1` से शुरू होता है।

Answer 18

यदि आपका काउंटर 1 से शुरू हो रहा है और आप खाली होने पर पहला नंबर अनुक्रम (1) उत्पन्न करना चाहते हैं, तो यहां ओरेकल के लिए मान्य पहले उत्तर से कोड का सही टुकड़ा है:

SELECT
  NVL(MIN(id + 1),1) AS gap
FROM
  mytable mo  
WHERE 1=1
  AND NOT EXISTS
      (
       SELECT  NULL
       FROM    mytable mi 
       WHERE   mi.id = mo.id + 1
      )
  AND EXISTS
     (
       SELECT  NULL
       FROM    mytable mi 
       WHERE   mi.id = 1
     )  

Answer 19

DECLARE @Table AS TABLE(
[Value] int
)

INSERT INTO @Table ([Value])
VALUES
 (1),(2),(4),(5),(6),(10),(20),(21),(22),(50),(51),(52),(53),(54),(55)
 --Gaps
 --Start    End     Size
 --3        3       1
 --7        9       3
 --11       19      9
 --23       49      27


SELECT [startTable].[Value]+1 [Start]
     ,[EndTable].[Value]-1 [End]
     ,([EndTable].[Value]-1) - ([startTable].[Value]) Size 
 FROM 
    (
SELECT [Value]
    ,ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY [Value]) Record
FROM @Table
)AS startTable
JOIN 
(
SELECT [Value]
,ROW_NUMBER() OVER(PARTITION BY 1 ORDER BY [Value]) Record
FROM @Table
)AS EndTable
ON [EndTable].Record = [startTable].Record+1
WHERE [startTable].[Value]+1 <>[EndTable].[Value]

Answer 20

यदि कॉलम में संख्याएँ पूर्णांक हैं (1 से शुरू) तो यहाँ बताया गया है कि इसे आसानी से कैसे हल किया जाए। (संभालने वाली आईडी आपका कॉलम नाम है)

    SELECT TEMP.ID 
    FROM (SELECT ROW_NUMBER() OVER () AS NUM FROM 'TABLE-NAME') AS TEMP 
    WHERE ID NOT IN (SELECT ID FROM 'TABLE-NAME')
    ORDER BY 1 ASC LIMIT 1

Comments

यह 'TABLE-NAME' में पंक्तियों की संख्या तक केवल "SELECT ROW_NUMBER () OVER () AS NUM FROM 'TABLE-NAME' के रूप में तब तक ही अंतराल पाएगा जब तक कि केवल पंक्तियों की संख्या तक आईडी न दें

— vayay shanker