Wie kann ich einen Wert finden, der in einer Tabelle nicht existiert?

Question

Ich habe eine vereinfachte Tabelle namens Bookings, die zwei Spalten BookDate und BookSlot hat. Die BookDate Spalte hat nur Daten (keine Zeit) und die BookSlot Spalte enthält die Uhrzeit des Tages in Intervallen von 30 Minuten von 0 bis einschließlich 1410. (d. h. 600 = 10:00 Uhr)

Wie kann ich den ersten verfügbaren Steckplatz in der Zukunft finden (nicht gebucht) ohne läuft durch eine Schleife? Hier

sind die Tabellendefinition und Testdaten:

Create Table Bookings(
    BookDate DateTime Not Null, 
    BookSlot Int Not Null 
) 
Go 

Insert Into Bookings(BookDate,BookSlot) Values('2014-07-01',0); 
Insert Into Bookings(BookDate,BookSlot) Values('2014-07-01',30); 
Insert Into Bookings(BookDate,BookSlot) Values('2014-07-01',60); 
Insert Into Bookings(BookDate,BookSlot) Values('2014-07-01',630); 
Insert Into Bookings(BookDate,BookSlot) Values('2014-07-02',60); 
Insert Into Bookings(BookDate,BookSlot) Values('2014-07-02',90); 
Insert Into Bookings(BookDate,BookSlot) Values('2014-07-02',120); 

Ich mag eine Möglichkeit, die erste freie Steckplatz zurückzugeben, die nicht in der Tabelle ist, und das ist in der Zukunft (basierend auf der Serverzeit).

Basierend auf obigen Testdaten:

• Wenn die aktuelle Serverzeit 1. Juli, 12.10 ist, soll das Ergebnis 1. Juli sein, 90min (01.30).
• Wenn die aktuelle Serverzeit 2. Juli, 01:05 war, sollte das Ergebnis 2. Juli, 150min (02:30) sein.

Wenn es in der Zukunft keine Buchungen gibt, würde die Funktion einfach die nächste halbe Stunde in der Zukunft zurückgeben.

-

SQL Fiddle dafür ist hier:

http://sqlfiddle.com/#!6/0e93d/1

Answer 1

try this:

SELECT a.bookdate, ((a.bookslot/60.)+.5) * 60 
FROM bookings a LEFT JOIN bookings b 
ON a.bookdate=b.bookdate AND (a.bookslot/60.)+.50=b.bookslot/60. 
WHERE b.bookslot IS null 

Answer 2

Es ist ein bisschen kompliziert, aber versuchen Sie dies:

WITH DATA 
    AS (SELECT *, 
       Row_number() 
        OVER ( 
        ORDER BY BOOKDATE, BOOKSLOT) RN 
     FROM BOOKINGS) 
SELECT CASE 
     WHEN T.BOOKSLOT = 1410 THEN Dateadd(DAY, 1, BOOKDATE) 
     ELSE BOOKDATE 
     END Book_Date, 
     CASE 
     WHEN T.BOOKSLOT = 1410 THEN 0 
     ELSE BOOKSLOT + 30 
     END Book_Slot 
FROM (SELECT TOP 1 T1.* 
     FROM DATA T1 
       LEFT JOIN DATA t2 
         ON t1.RN = T2.RN - 1 
     WHERE t2.BOOKSLOT - t1.BOOKSLOT > 30 
       OR (t1.BOOKDATE != T2.BOOKDATE 
        AND (t2.BOOKSLOT != 0 
          OR t1.BOOKSLOT != 630)) 
       OR t2.BOOKSLOT IS NULL)T 

Hier ist das SQL fiddle Beispiel.

Erklärung

Diese Lösung besteht aus 2 Teilen:

1. jede Zeile zur nächsten und überprüft für eine Lücke Vergleich (in SQL 2012 leichter gemacht werden)
2. Hinzufügen einer halben Stunde, um den nächsten Slot zu erstellen, schließt dies bei Bedarf den nächsten Tag ein.

bearbeiten

Added TOP 1 in der Abfrage, so dass nur der erste Schlitz wird wie gewünscht zurückgegeben.

aktualisieren

Hier ist die aktualisierte Version, darunter 2 neue Elemente (aktuelles Datum + Uhrzeit und den Umgang mit leeren Tisch zu bekommen):

DECLARE @Date DATETIME = '2014-07-01', 
     @Slot INT = 630 
DECLARE @time AS TIME = Cast(Getdate() AS TIME) 

SELECT @Slot = Datepart(HOUR, @time) * 60 + Round(Datepart(MINUTE, @time)/30, 
              0) * 30 
         + 30 

SET @Date = Cast(Getdate() AS DATE) 


;WITH DATA 
    AS (SELECT *, 
       Row_number() 
        OVER ( 
        ORDER BY BOOKDATE, BOOKSLOT) RN 
     FROM BOOKINGS 
     WHERE BOOKDATE > @Date 
       OR (BOOKDATE = @Date 
         AND BOOKSLOT >= @Slot)) 
SELECT TOP 1 BOOK_DATE, 
      BOOK_SLOT 
FROM (SELECT CASE 
       WHEN RN = 1 
         AND NOT (@slot = BOOKSLOT 
         AND @Date = BOOKDATE) THEN @Date 
       WHEN T.BOOKSLOT = 1410 THEN Dateadd(DAY, 1, BOOKDATE) 
       ELSE BOOKDATE 
       END Book_Date, 
       CASE 
       WHEN RN = 1 
         AND NOT (@slot = BOOKSLOT 
         AND @Date = BOOKDATE) THEN @Slot 
       WHEN T.BOOKSLOT = 1410 THEN 0 
       ELSE BOOKSLOT + 30 
       END Book_Slot, 
       1 AS ID 
     FROM (SELECT TOP 1 T1.* 
       FROM DATA T1 
         LEFT JOIN DATA t2 
           ON t1.RN = T2.RN - 1 
       WHERE t2.BOOKSLOT - t1.BOOKSLOT > 30 
         OR (t1.BOOKDATE != T2.BOOKDATE 
          AND (t2.BOOKSLOT != 0 
            OR t1.BOOKSLOT != 1410)) 
         OR t2.BOOKSLOT IS NULL)T 
     UNION 
     SELECT @date AS bookDate, 
       @slot AS BookSlot, 
       2  ID)X 
ORDER BY X.ID 

mit dem SQL fiddle Spielen Sie herum und lassen Sie mich wissen, was Sie denken.

Answer 3

In SQL Server 2012 und höher können Sie die Funktion lead() verwenden. Die Logik ist wegen aller Randbedingungen ein wenig verschachtelt. Ich denke, das fängt es:

select top 1 
     (case when BookSlot = 1410 then BookDate else BookDate + 1 end) as BookDate, 
     (case when BookSlot = 1410 then 0 else BookSlot + 30 end) as BookSlot 
from (select b.*, 
      lead(BookDate) over (order by BookDate) as next_dt, 
      lead(BookSlot) over (partition by BookDate order by BookSlot) as next_bs 
     from bookings b 
    ) b 
where (next_bs is null and BookSlot < 1410 or 
     next_bs - BookSlot > 30 or 
     BookSlot = 1410 and (next_dt <> BookDate + 1 or next_dt = BookDate and next_bs <> 0) 
    ) 
order by BookDate, BookSlot; 

Answer 4

Im Folgenden eine Methode, die Buchungen bis zu 256 Tagen in der Zukunft ermöglichen wird, und für einen leeren Reservierungstisch ermöglichen. Ich nehme an, dass Sie SQL Server 2005 verwenden, da Ihr BookDate dateTime anstelle von date ist.
In jedem Fall sollten Sie die Slots als vollständige datetime statt als separate Spalten speichern. Das erleichtert Abfragen und verbessert die Leistung.

DECLARE @now DATETIME = '2014-07-01 00:10:00'; 

WITH T4 
    AS (SELECT N 
     FROM (VALUES(0), 
         (0), 
         (0), 
         (0), 
         (0), 
         (0), 
         (0), 
         (0)) AS t(N)), 
    T256 
    AS (SELECT Row_number() 
        OVER( 
        ORDER BY (SELECT 0)) - 1 AS n 
     FROM T4 AS a 
       CROSS JOIN T4 AS b 
       CROSS JOIN T4 AS c), 
    START_DATE 
    AS (SELECT Dateadd(DAY, Datediff(DAY, '', @now), '') AS start_date), 
    START_TIME 
    AS (SELECT Dateadd(MINUTE, Datediff(MINUTE, '', @now)/30 * 30, '') AS 
       start_time), 
    DAILY_INTERVALS 
    AS (SELECT N * 30 AS interval 
     FROM T256 
     WHERE N < 48) 
SELECT TOP (1) Dateadd(DAY, future_days.N, START_DATE) AS BookDate, 
       DAILY_INTERVALS.INTERVAL    AS BookSlot 
FROM START_DATE 
     CROSS APPLY START_TIME 
     CROSS APPLY DAILY_INTERVALS 
     CROSS APPLY T256 AS future_days 
WHERE Dateadd(MINUTE, DAILY_INTERVALS.INTERVAL, 
       Dateadd(DAY, future_days.N, START_DATE)) > START_TIME 
     AND NOT EXISTS(SELECT * 
         FROM DBO.BOOKINGS 
         WHERE BOOKDATE = START_DATE 
          AND BOOKSLOT = DAILY_INTERVALS.INTERVAL) 
ORDER BY BOOKDATE, 
      BOOKSLOT; 

Sehen Sie diese SQL Fiddle

Answer 5

Mit einer tally Tabelle eine Liste der ursprünglich verfügbaren Buchungs Slots aus 6 Wochen (einstellbar unten) zu erzeugen:

declare @Date as date = getdate(); 
declare @slot as int = 30 * (datediff(n,@Date,getdate()) /30); 

with 
slots as (
    select (ROW_NUMBER() over (order by s)-1) * 30 as BookSlot 
    from(
     values (1),(1),(1),(1),(1),(1),(1),(1) -- 4 hour block 
    )slots(s) 
    cross join (
     values (1),(1),(1),(1),(1),(1) -- 6 blocks of 4 hours each day 
    )QuadHours(t) 
) 
,days as (
    select (ROW_NUMBER() over (order by s)-1) + getdate() as BookDate 
    from (
     values (1),(1),(1),(1),(1),(1),(1) -- 7 days in a week 
    )dayList(s) 
    cross join (
     -- set this to number of weeks out to allow bookings to be made 
     values (1),(1),(1),(1),(1),(1)  -- allow 6 weeks of bookings at a time 
    )weeks(t) 
) 
,tally as (
    select 
     cast(days.BookDate as date) as BookDate 
     ,slots.BookSlot    as BookSLot 
    from slots 
    cross join days 
) 

select top 1 
    tally.BookDate 
    ,tally.BookSlot 
from tally 
left join #Bookings book 
    on tally.BookDate = book.BookDate 
    and tally.BookSlot = book.BookSlot 
where book.BookSlot is null 
    and (tally.BookDate > @Date or tally.BookSlot > @slot) 
order by tally.BookDate,tally.BookSlot; 

go