表から「n」個の連続した無料番号を見つける

このような数字のテーブルがあります（ステータスはFREEまたはASSIGNEDです）

id_set番号ステータス         
-----------------------
1 000001割り当て済み
1 000002無料
1 000003割り当て済み
1 000004無料
1 000005無料
1 000006割り当て済み
10007割り当て済み
1 000008無料
1 000009無料
1 000010無料
1 000011割り当て済み
1 000012割り当て済み
1 000013割り当て済み
1 000014無料
1 000015割り当て済み

「n」個の連続した番号を見つける必要があるため、n = 3の場合、クエリは

1 000008無料
1 000009無料
1 000010無料

各id_setの最初の可能なグループのみを返す必要があります（実際、クエリごとにid_setに対してのみ実行されます）

私はWINDOW関数をチェックしてCOUNT(id_number) OVER (PARTITION BY id_set ROWS UNBOUNDED PRECEDING)いましたが、のようなクエリをいくつか試しましたが、それだけでした:) Postgresでそれを行う方法、ロジックを考えることができませんでした。

status = 'FREE'であるすべての番号の前の行をカウントするWINDOW関数を使用して仮想列を作成し、最初の番号を選択することを考えていました。

または、ステータスごとに番号をグループ化しますが、1つのASSIGNEDから別のASSIGNEDにのみ、少なくとも「n」の番号を含むグループのみを選択します。

編集

このクエリを見つけました（少し変更しました）

WITH q AS
(
  SELECT *,
         ROW_NUMBER() OVER (PARTITION BY id_set, status ORDER BY number) AS rnd,
         ROW_NUMBER() OVER (PARTITION BY id_set ORDER BY number) AS rn
  FROM numbers
)
SELECT id_set,
       MIN(number) AS first_number,
       MAX(number) AS last_number,
       status,
       COUNT(number) AS numbers_count
FROM q
GROUP BY id_set,
         rnd - rn,
         status
ORDER BY
     first_number

FREE / ASSIGNED番号のグループを生成しますが、条件に一致する最初のグループのみからすべての番号を取得したいです

SQLフィドル

これは、ギャップと島の問題です。同じid_setセットにギャップや重複がないと仮定します。

WITH partitioned AS (
  SELECT
    *,
    number - ROW_NUMBER() OVER (PARTITION BY id_set) AS grp
  FROM atable
  WHERE status = 'FREE'
),
counted AS (
  SELECT
    *,
    COUNT(*) OVER (PARTITION BY id_set, grp) AS cnt
  FROM partitioned
)
SELECT
  id_set,
  number
FROM counted
WHERE cnt >= 3
;

ここではSQLフィドルのデモです^*：このクエリのリンクhttp://sqlfiddle.com/#!1/a2633/1が。

更新

1つのセットのみを返すには、さらに1ラウンドのランキングを追加できます。

WITH partitioned AS (
  SELECT
    *,
    number - ROW_NUMBER() OVER (PARTITION BY id_set) AS grp
  FROM atable
  WHERE status = 'FREE'
),
counted AS (
  SELECT
    *,
    COUNT(*) OVER (PARTITION BY id_set, grp) AS cnt
  FROM partitioned
),
ranked AS (
  SELECT
    *,
    RANK() OVER (ORDER BY id_set, grp) AS rnk
  FROM counted
  WHERE cnt >= 3
)
SELECT
  id_set,
  number
FROM ranked
WHERE rnk = 1
;

これのデモもここにあります：http : //sqlfiddle.com/#! 1/ a2633/2。

あなたは今までそれ1セットにする必要がある場合につきid_set、変更RANK()、このような呼び出しを：

RANK() OVER (PARTITION BY id_set ORDER BY grp) AS rnk

さらに、次のように、クエリが最小の一致セットを返すようにすることができます（つまり、存在する場合は正確に3つの連続した数字の最初のセットを返します）。

RANK() OVER (ORDER BY cnt, id_set, grp) AS rnk

またはこのように（ごとに1つid_set）：

RANK() OVER (PARTITION BY id_set ORDER BY cnt, grp) AS rnk

_{*この回答にリンクされているSQL Fiddleデモでは、現時点では機能していないように見える9.2.1として9.1.8インスタンスを使用しています。}

シンプルで高速なバリアント：

SELECT min(number) AS first_number, count(*) AS ct_free
FROM (
    SELECT *, number - row_number() OVER (PARTITION BY id_set ORDER BY number) AS grp
    FROM   tbl
    WHERE  status = 'FREE'
    ) x
GROUP  BY grp
HAVING count(*) >= 3  -- minimum length of sequence only goes here
ORDER  BY grp
LIMIT  1;

• number（質問で提供されているように）にギャップのない一連の数字が必要です。

• 可能な値の任意の数の作品status以外にも'FREE'、さえしてNULL。

• 主な機能は、非修飾行を削除row_number()したnumber後から減算することです。連続した数字が同じに終わるgrp-とgrpもであることが保証され昇順。

• その後GROUP BY grp、メンバーを数えることができます。あなたは最初の出現を望んでいるようORDER BY grp LIMIT 1で、シーケンスの開始位置と長さを取得するので（> = nにできます）

行のセット

実際の数値セットを取得するには、もう一度テーブルを検索しないでください。ではるかに安いgenerate_series()：

SELECT generate_series(first_number, first_number + ct_free - 1)
    -- generate_series(first_number, first_number + 3 - 1) -- only 3
FROM  (
   SELECT min(number) AS first_number, count(*) AS ct_free
   FROM  (
      SELECT *, number - row_number() OVER (PARTITION BY id_set ORDER BY number) AS grp
      FROM   tbl
      WHERE  status = 'FREE'
      ) x
   GROUP  BY grp
   HAVING count(*) >= 3
   ORDER  BY grp
   LIMIT  1
   ) y;

サンプル値に表示するように、実際に先行ゼロ付きの文字列が必要な場合to_char()は、FM（fill mode）修飾子を使用します。

SELECT to_char(generate_series(8, 11), 'FM000000')

拡張テストケースと両方のクエリを備えた SQL Fiddle。

密接に関連した答え：

• 最長連続シーケンスを選択

これは、これを行うためのかなり一般的な方法です。

number列が連続していることに依存することに注意してください。Window関数やCTEタイプソリューションでない場合は、おそらく必要になります。

SELECT 
    number
FROM
    mytable m
CROSS JOIN
   (SELECT 3 AS consec) x
WHERE 
    EXISTS
       (SELECT 1 
        FROM mytable
        WHERE number = m.number - x.consec + 1
        AND status = 'FREE')
    AND NOT EXISTS
       (SELECT 1 
        FROM mytable
        WHERE number BETWEEN m.number - x.consec + 1 AND m.number
        AND status = 'ASSIGNED')

これは、3つの数値のうち最初の数値のみを返します。の値numberが連続している必要はありません。SQL-Fiddleでテスト済み：

WITH cte3 AS
( SELECT
    *,
    COUNT(CASE WHEN status = 'FREE' THEN 1 END) 
        OVER (PARTITION BY id_set ORDER BY number
              ROWS BETWEEN CURRENT ROW AND 2 FOLLOWING)
      AS cnt
  FROM atable
)
SELECT
  id_set, number
FROM cte3
WHERE cnt = 3 ;

そして、これはすべての数字を表示します（3つ以上の連続した'FREE'位置がある場合）：

WITH cte3 AS
( SELECT
    *,
    COUNT(CASE WHEN status = 'FREE' THEN 1 END) 
        OVER (PARTITION BY id_set ORDER BY number
              ROWS BETWEEN CURRENT ROW AND 2 FOLLOWING)
      AS cnt
  FROM atable
)
, cte4 AS
( SELECT
    *, 
    MAX(cnt) 
        OVER (PARTITION BY id_set ORDER BY number
              ROWS BETWEEN 2 PRECEDING AND CURRENT ROW)
      AS maxcnt
  FROM cte3
)
SELECT
  id_set, number
FROM cte4
WHERE maxcnt >= 3 ;

select r1.number from some_table r1, 
some_table r2,
some_table r3,
some_table r4 
where r3.number <= r2.number 
and r3.number >= r1.number 
and r3.status = 'FREE' 
and r2.number = r1.number + 4 
and r4.number <= r2.number 
and r4.number >= r1.number 
and r4.status = 'ASSIGNED'
group by r1.number, r2.number having count(r3.number) = 5 and count(r4.number) = 0 order by r1.number asc limit 1 ;

この場合、5つの連続番号-従って差が4または他の言葉でなければならないcount(r3.number) = nとr2.number = r1.number + n - 1。

結合あり：

select r1.number 
from some_table r1 join 
 some_table r2 on (r2.number = r1.number + :n -1) join
 some_table r3 on (r3.number <= r2.number and r3.number >= r1.number) join
 some_table r4 on (r4.number <= r2.number and r4.number >= r1.number)
where  
 r3.status = 'FREE' and
 r4.status = 'ASSIGNED'
group by r1.number, r2.number having count(r3.number) = :n and count(r4.number) = 0 order by r1.number asc limit 1 ;

CREATE TABLE #ConsecFreeNums
(
     id_set BIGINT
    ,number VARCHAR(10)
    ,status VARCHAR(10)
)

CREATE TABLE #ConsecFreeNumsResult
(
     Seq    INT
    ,id_set BIGINT
    ,number VARCHAR(10)
    ,status VARCHAR(10)
)

INSERT #ConsecFreeNums
SELECT 1, '000002', 'FREE' UNION
SELECT 1, '000003', 'ASSIGNED' UNION
SELECT 1, '000004', 'FREE' UNION
SELECT 1, '000005', 'FREE' UNION
SELECT 1, '000006', 'ASSIGNED' UNION
SELECT 1, '000007', 'ASSIGNED' UNION
SELECT 1, '000008', 'FREE' UNION
SELECT 1, '000009', 'FREE' UNION
SELECT 1, '000010', 'FREE' UNION
SELECT 1, '000011', 'ASSIGNED' UNION
SELECT 1, '000012', 'ASSIGNED' UNION
SELECT 1, '000013', 'ASSIGNED' UNION
SELECT 1, '000014', 'FREE' UNION
SELECT 1, '000015', 'ASSIGNED'

DECLARE @id_set AS BIGINT, @number VARCHAR(10), @status VARCHAR(10), @number_count INT, @number_count_check INT

DECLARE ConsecFreeNumsCursor CURSOR FAST_FORWARD FOR
SELECT
       id_set
      ,number
      ,status
 FROM
      #ConsecFreeNums
WHERE id_set = 1
ORDER BY number

OPEN ConsecFreeNumsCursor

FETCH NEXT FROM ConsecFreeNumsCursor INTO @id_set, @number, @status

SET @number_count_check = 3
SET @number_count = 0

WHILE @@FETCH_STATUS = 0
BEGIN
    IF @status = 'ASSIGNED'
    BEGIN
        IF @number_count = @number_count_check
        BEGIN
            SELECT 'Results'
            SELECT * FROM #ConsecFreeNumsResult ORDER BY number
            BREAK
        END
        SET @number_count = 0
        TRUNCATE TABLE #ConsecFreeNumsResult
    END
    ELSE
    BEGIN
        SET @number_count = @number_count + 1
        INSERT #ConsecFreeNumsResult SELECT @number_count, @id_set, @number, @status
    END
    FETCH NEXT FROM ConsecFreeNumsCursor INTO @id_set, @number, @status
END

CLOSE ConsecFreeNumsCursor
DEALLOCATE ConsecFreeNumsCursor

DROP TABLE #ConsecFreeNums
DROP TABLE #ConsecFreeNumsResult