it-swarm.com.de

So finden Sie rekursiv Lücken zwischen Zeilen, in denen 90 Tage vergangen sind

Dies ist eine triviale Aufgabe in meiner C # -Homeeworld, aber ich mache es noch nicht in SQL und würde es vorziehen, es satzbasiert (ohne Cursor) zu lösen. Eine Ergebnismenge sollte aus einer solchen Abfrage stammen.

SELECT SomeId, MyDate, 
    dbo.udfLastHitRecursive(param1, param2, MyDate) as 'Qualifying'
FROM T

Wie soll es funktionieren

Ich sende diese drei Parameter in eine UDF.
Die UDF verwendet intern Parameter, um verwandte <= 90 Tage ältere Zeilen aus einer Ansicht abzurufen.
Die UDF durchläuft 'MyDate' und gibt 1 zurück, wenn es in eine Gesamtberechnung einbezogen werden soll.
Sollte dies nicht der Fall sein, wird 0 zurückgegeben. Hier als "qualifizierend" bezeichnet.

Was der UDF tun wird

Listen Sie die Zeilen in Datumsreihenfolge auf. Berechnen Sie die Tage zwischen den Zeilen. Die erste Zeile in der Ergebnismenge ist standardmäßig Treffer = 1. Wenn die Differenz bis zu 90 beträgt, - dann zur nächsten Zeile übergehen, bis die Summe der Lücken 90 Tage beträgt (90. Tag muss vergehen). Wenn erreicht, setzen Sie Treffer auf 1 und setzen Sie die Lücke auf 0 zurück Es würde auch funktionieren, stattdessen die Zeile aus dem Ergebnis wegzulassen.

                                          |(column by udf, which not work yet)
Date              Calc_date     MaxDiff   | Qualifying
2014-01-01 11:00  2014-01-01    0         | 1
2014-01-03 10:00  2014-01-01    2         | 0
2014-01-04 09:30  2014-01-03    1         | 0
2014-04-01 10:00  2014-01-04    87        | 0
2014-05-01 11:00  2014-04-01    30        | 1

In der obigen Tabelle ist die MaxDiff-Spalte die Lücke vom Datum in der vorherigen Zeile. Das Problem bei meinen bisherigen Versuchen ist, dass ich die vorletzte Zeile im obigen Beispiel nicht ignorieren kann.

[EDIT]
Gemäß Kommentar füge ich ein Tag hinzu und füge auch das udf ein, das ich gerade kompiliert habe. Ist jedoch nur ein Platzhalter und liefert kein nützliches Ergebnis.

;WITH cte (someid, otherkey, mydate, cost) AS
(
    SELECT someid, otherkey, mydate, cost
    FROM dbo.vGetVisits
    WHERE someid = @someid AND VisitCode = 3 AND otherkey = @otherkey 
    AND CONVERT(Date,mydate) = @VisitDate

    UNION ALL

    SELECT top 1 e.someid, e.otherkey, e.mydate, e.cost
    FROM dbo.vGetVisits AS E
    WHERE CONVERT(date, e.mydate) 
        BETWEEN DateAdd(dd,-90,CONVERT(Date,@VisitDate)) AND CONVERT(Date,@VisitDate)
        AND e.someid = @someid AND e.VisitCode = 3 AND e.otherkey = @otherkey 
        AND CONVERT(Date,e.mydate) = @VisitDate
        order by e.mydate
)

Ich habe eine andere Abfrage, die ich separat definiere, die näher an dem liegt, was ich brauche, aber blockiert durch die Tatsache, dass ich nicht mit Fensterspalten rechnen kann. Ich habe auch ein ähnliches versucht, das mehr oder weniger dieselbe Ausgabe nur mit einer LAG () über MyDate liefert, umgeben von einem datierteniff.

SELECT
    t.Mydate, t.VisitCode, t.Cost, t.SomeId, t.otherkey, t.MaxDiff, t.DateDiff
FROM 
(
    SELECT *,
        MaxDiff = LAST_VALUE(Diff.Diff)  OVER (
            ORDER BY Diff.Mydate ASC
                ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
    FROM 
    (
        SELECT *,
            Diff =  ISNULL(DATEDIFF(DAY, LAST_VALUE(r.Mydate) OVER (
                        ORDER BY r.Mydate ASC
                            ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING), 
                                r.Mydate),0),
            DateDiff =  ISNULL(LAST_VALUE(r.Mydate) OVER (
                        ORDER BY r.Mydate ASC
                            ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING), 
                                r.Mydate)
        FROM dbo.vGetVisits AS r
        WHERE r.VisitCode = 3 AND r.SomeId = @SomeID AND r.otherkey = @otherkey
    ) AS Diff
) AS t
WHERE t.VisitCode = 3 AND t.SomeId = @SomeId AND t.otherkey = @otherkey
    AND t.Diff <= 90
ORDER BY
    t.Mydate ASC;
18
Independent

Während ich die Frage lese, ist der grundlegende rekursive Algorithmus erforderlich:

  1. Geben Sie die Zeile mit dem frühesten Datum im Satz zurück
  2. Stellen Sie dieses Datum als "aktuell" ein.
  3. Suchen Sie die Zeile mit dem frühesten Datum mehr als 90 Tage nach dem aktuellen Datum
  4. Wiederholen Sie den Vorgang ab Schritt 2, bis keine Zeilen mehr gefunden werden

Dies ist mit einem rekursiven allgemeinen Tabellenausdruck relativ einfach zu implementieren.

Verwenden Sie beispielsweise die folgenden Beispieldaten (basierend auf der Frage):

DECLARE @T AS table (TheDate datetime PRIMARY KEY);

INSERT @T (TheDate)
VALUES
    ('2014-01-01 11:00'),
    ('2014-01-03 10:00'),
    ('2014-01-04 09:30'),
    ('2014-04-01 10:00'),
    ('2014-05-01 11:00'),
    ('2014-07-01 09:00'),
    ('2014-07-31 08:00');

Der rekursive Code lautet:

WITH CTE AS
(
    -- Anchor:
    -- Start with the earliest date in the table
    SELECT TOP (1)
        T.TheDate
    FROM @T AS T
    ORDER BY
        T.TheDate

    UNION ALL

    -- Recursive part   
    SELECT
        SQ1.TheDate
    FROM 
    (
        -- Recursively find the earliest date that is 
        -- more than 90 days after the "current" date
        -- and set the new date as "current".
        -- ROW_NUMBER + rn = 1 is a trick to get
        -- TOP in the recursive part of the CTE
        SELECT
            T.TheDate,
            rn = ROW_NUMBER() OVER (
                ORDER BY T.TheDate)
        FROM CTE
        JOIN @T AS T
            ON T.TheDate > DATEADD(DAY, 90, CTE.TheDate)
    ) AS SQ1
    WHERE
        SQ1.rn = 1
)
SELECT 
    CTE.TheDate 
FROM CTE
OPTION (MAXRECURSION 0);

Die Ergebnisse sind:

╔═════════════════════════╗
║         TheDate         ║
╠═════════════════════════╣
║ 2014-01-01 11:00:00.000 ║
║ 2014-05-01 11:00:00.000 ║
║ 2014-07-31 08:00:00.000 ║
╚═════════════════════════╝

Mit einem Index mit TheDate als führendem Schlüssel ist der Ausführungsplan sehr effizient:

Execution plan

Sie können dies in eine Funktion einschließen und direkt gegen die in der Frage erwähnte Ansicht ausführen, aber meine Instinkte sind dagegen. Normalerweise ist die Leistung besser, wenn Sie Zeilen aus einer Ansicht in eine temporäre Tabelle auswählen, den entsprechenden Index für die temporäre Tabelle bereitstellen und dann die obige Logik anwenden. Die Details hängen von den Details der Ansicht ab, aber dies ist meine allgemeine Erfahrung.

Der Vollständigkeit halber (und veranlasst durch die Antwort von ypercube) sollte ich erwähnen, dass meine andere Lösung für diese Art von Problem (bis T-SQL die richtigen geordneten Set-Funktionen erhält) ein SQLCLR-Cursor ist ( siehe meine Antwort hier = für ein Beispiel der Technik). Dies ist viel besser als ein T-SQL-Cursor und praktisch für Benutzer mit Kenntnissen in .NET-Sprachen und der Fähigkeit, SQLCLR in ihrer Produktionsumgebung auszuführen . In diesem Szenario bietet es möglicherweise nicht viel über die rekursive Lösung, da der Großteil der Kosten in der Art liegt, aber es ist erwähnenswert.

23
Paul White 9

Da dies eine SQL Server 2014-Frage ist, kann ich auch eine nativ kompilierte Version eines "Cursors" für gespeicherte Prozeduren hinzufügen.

Quelltabelle mit einigen Daten:

create table T 
(
  TheDate datetime primary key
);

go

insert into T(TheDate) values
('2014-01-01 11:00'),
('2014-01-03 10:00'),
('2014-01-04 09:30'),
('2014-04-01 10:00'),
('2014-05-01 11:00'),
('2014-07-01 09:00'),
('2014-07-31 08:00');

Ein Tabellentyp, der der Parameter der gespeicherten Prozedur ist. Passen Sie den bucket_count Entsprechend an .

create type TType as table
(
  ID int not null primary key nonclustered hash with (bucket_count = 16),
  TheDate datetime not null
) with (memory_optimized = on);

Und eine gespeicherte Prozedur, die den Tabellenwertparameter durchläuft und die Zeilen in @R Sammelt.

create procedure dbo.GetDates
  @T dbo.TType readonly
with native_compilation, schemabinding, execute as owner 
as
begin atomic with (transaction isolation level = snapshot, language = N'us_english', delayed_durability = on)

  declare @R dbo.TType;
  declare @ID int = 0;
  declare @RowsLeft bit = 1;  
  declare @CurDate datetime = '1901-01-01';
  declare @LastDate datetime = '1901-01-01';

  while @RowsLeft = 1
  begin
    set @ID += 1;

    select @CurDate = T.TheDate
    from @T as T
    where T.ID = @ID

    if @@rowcount = 1
    begin
      if datediff(day, @LastDate, @CurDate) > 90
      begin
        insert into @R(ID, TheDate) values(@ID, @CurDate);
        set @LastDate = @CurDate;
      end;
    end
    else
    begin
      set @RowsLeft = 0;
    end

  end;

  select R.TheDate
  from @R as R;
end

Code zum Füllen einer speicheroptimierten Tabellenvariablen, die als Parameter für die nativ kompilierte gespeicherte Prozedur verwendet wird, und Aufrufen der Prozedur.

declare @T dbo.TType;

insert into @T(ID, TheDate)
select row_number() over(order by T.TheDate),
       T.TheDate
from T;

exec dbo.GetDates @T;

Ergebnis:

TheDate
-----------------------
2014-07-31 08:00:00.000
2014-01-01 11:00:00.000
2014-05-01 11:00:00.000

Aktualisieren:

Wenn Sie aus irgendeinem Grund nicht jede Zeile in der Tabelle besuchen müssen, können Sie das Äquivalent der Version "Zum nächsten Datum springen" ausführen, die im rekursiven CTE von Paul White implementiert ist.

Der Datentyp benötigt keine ID-Spalte und Sie sollten keinen Hash-Index verwenden.

create type TType as table
(
  TheDate datetime not null primary key nonclustered
) with (memory_optimized = on);

Und die gespeicherte Prozedur verwendet eine select top(1) .., um den nächsten Wert zu finden.

create procedure dbo.GetDates
  @T dbo.TType readonly
with native_compilation, schemabinding, execute as owner 
as
begin atomic with (transaction isolation level = snapshot, language = N'us_english', delayed_durability = on)

  declare @R dbo.TType;
  declare @RowsLeft bit = 1;  
  declare @CurDate datetime = '1901-01-01';

  while @RowsLeft = 1
  begin

    select top(1) @CurDate = T.TheDate
    from @T as T
    where T.TheDate > dateadd(day, 90, @CurDate)
    order by T.TheDate;

    if @@rowcount = 1
    begin
      insert into @R(TheDate) values(@CurDate);
    end
    else
    begin
      set @RowsLeft = 0;
    end

  end;

  select R.TheDate
  from @R as R;
end
9
Mikael Eriksson

Eine Lösung, die einen Cursor verwendet.
(zuerst einige benötigte Tabellen und Variablen):

-- a table to hold the results
DECLARE @cd TABLE
(   TheDate datetime PRIMARY KEY,
    Qualify INT NOT NULL
);

-- some variables
DECLARE
    @TheDate DATETIME,
    @diff INT,
    @Qualify     INT = 0,
    @PreviousCheckDate DATETIME = '1900-01-01 00:00:00' ;

Der eigentliche Cursor:

-- declare the cursor
DECLARE c CURSOR
    LOCAL STATIC FORWARD_ONLY READ_ONLY
    FOR
    SELECT TheDate
      FROM T
      ORDER BY TheDate ;

-- using the cursor to fill the @cd table
OPEN c ;

FETCH NEXT FROM c INTO @TheDate ;

WHILE @@FETCH_STATUS = 0
BEGIN
    SET @diff = DATEDIFF(day, @PreviousCheckDate, @Thedate) ;
    SET @Qualify = CASE WHEN @diff > 90 THEN 1 ELSE 0 END ;

    INSERT @cd (TheDate, Qualify)
        SELECT @TheDate, @Qualify ;

    SET @PreviousCheckDate = 
            CASE WHEN @diff > 90 
                THEN @TheDate 
                ELSE @PreviousCheckDate END ;

    FETCH NEXT FROM c INTO @TheDate ;
END

CLOSE c;
DEALLOCATE c;

Und die Ergebnisse erhalten:

-- get the results
SELECT TheDate, Qualify
    FROM @cd
    -- WHERE Qualify = 1        -- optional, to see only the qualifying rows
    ORDER BY TheDate ;

Getestet bei SQLFiddle

5
ypercubeᵀᴹ
IF  EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[vGetVisits]') AND type in (N'U'))
DROP TABLE [dbo].[vGetVisits]
GO

CREATE TABLE [dbo].[vGetVisits](
    [id] [int] NOT NULL,
    [mydate] [datetime] NOT NULL,
 CONSTRAINT [PK_vGetVisits] PRIMARY KEY CLUSTERED 
(
    [id] ASC
)
)

GO

INSERT INTO [dbo].[vGetVisits]([id], [mydate])
VALUES
    (1, '2014-01-01 11:00'),
    (2, '2014-01-03 10:00'),
    (3, '2014-01-04 09:30'),
    (4, '2014-04-01 10:00'),
    (5, '2014-05-01 11:00'),
    (6, '2014-07-01 09:00'),
    (7, '2014-07-31 08:00');
GO


-- Clean up 
IF OBJECT_ID (N'dbo.udfLastHitRecursive', N'FN') IS NOT NULL
DROP FUNCTION udfLastHitRecursive;
GO

-- Actual Function  
CREATE FUNCTION dbo.udfLastHitRecursive
( @MyDate datetime)

RETURNS TINYINT

AS
    BEGIN 
        -- Your returned value 1 or 0
        DECLARE @Returned_Value TINYINT;
        SET @Returned_Value=0;
    -- Prepare gaps table to be used.
    WITH gaps AS
    (
                        -- Select Date and MaxDiff from the original table
                        SELECT 
                        CONVERT(Date,mydate) AS [date]
                        , DATEDIFF(day,ISNULL(LAG(mydate, 1) OVER (ORDER BY mydate), mydate) , mydate) AS [MaxDiff]
                        FROM dbo.vGetVisits
    )

        SELECT @Returned_Value=
            (SELECT DISTINCT -- DISTINCT in case we have same date but different time
                    CASE WHEN
                     (
                    -- It is a first entry
                    [date]=(SELECT MIN(CONVERT(Date,mydate)) FROM dbo.vGetVisits))
                    OR 
                    /* 
                    --Gap between last qualifying date and entered is greater than 90 
                        Calculate Running sum upto and including required date 
                        and find a remainder of division by 91. 
                    */
                     ((SELECT SUM(t1.MaxDiff)  
                    FROM (SELECT [MaxDiff] FROM gaps WHERE [date]<=t2.[date] 
                    ) t1 
                    )%91 - 
                    /* 
                        ISNULL added to include first value that always returns NULL 
                        Calculate Running sum upto and NOT including required date 
                        and find a remainder of division by 91 
                    */
                    ISNULL((SELECT SUM(t1.MaxDiff)  
                    FROM (SELECT [MaxDiff] FROM gaps WHERE [date]<t2.[date] 
                    ) t1 
                    )%91, 0) -- End ISNULL
                     <0 )
                    /* End Running sum upto and including required date */
                    OR
                    -- Gap between two nearest dates is greater than 90 
                    ((SELECT SUM(t1.MaxDiff)  
                    FROM (SELECT [MaxDiff] FROM gaps WHERE [date]<=t2.[date] 
                    ) t1 
                    ) - ISNULL((SELECT SUM(t1.MaxDiff)  
                    FROM (SELECT [MaxDiff] FROM gaps WHERE [date]<t2.[date] 
                    ) t1 
                    ), 0) > 90) 
                    THEN 1
                    ELSE 0
                    END 
                    AS [Qualifying]
                    FROM gaps t2
                    WHERE [date]=CONVERT(Date,@MyDate))
        -- What is neccesary to return when entered date is not in dbo.vGetVisits?
        RETURN @Returned_Value
    END
GO

SELECT 
dbo.udfLastHitRecursive(mydate) AS [Qualifying]
, [id]
, mydate 
FROM dbo.vGetVisits
ORDER BY mydate 

Ergebnis

enter image description here

Schauen Sie sich auch So berechnen Sie die laufende Summe in SQL Server an

update: Bitte sehen Sie unten die Ergebnisse der Leistungstests.

Aufgrund der unterschiedlichen Logik, die beim Finden von "90-Tage-Lücke" verwendet wird, können Ypercubes und meine Lösungen, wenn sie intakt bleiben, unterschiedliche Ergebnisse zu Paul Whites Lösung zurückgeben. Dies ist auf die Verwendung von [~ # ~] datierten [~ # ~] und [~ # ~] dateadd [~ # ~] Funktionen zurückzuführen .

Zum Beispiel:

SELECT DATEADD(DAY, 90, '2014-01-01 00:00:00.000')

gibt '2014-04-01 00: 00: 00.000' zurück, was bedeutet, dass '2014-04-01 01: 00: 00.000' eine Lücke von mehr als 90 Tagen hat

aber

SELECT DATEDIFF(DAY, '2014-01-01 00:00:00.000', '2014-04-01 01:00:00.000')

Gibt '90' zurück, was bedeutet, dass es sich immer noch innerhalb der Lücke befindet.

Betrachten Sie ein Beispiel eines Einzelhändlers. In diesem Fall ist der Verkauf eines verderblichen Produkts mit dem Verfallsdatum '2014-01-01' am '2014-01-01 23: 59: 59: 999' in Ordnung. Der Wert DATEDIFF (DAY, ...) ist in diesem Fall also in Ordnung.

Ein anderes Beispiel ist ein Patient, der darauf wartet, gesehen zu werden. Für jemanden, der um '2014-01-01 00: 00: 00: 000' kommt und um '2014-01-01 23: 59: 59: 999' geht, ist es 0(zero) = Tage, an denen DATEDIFF verwendet wird, obwohl die tatsächliche Wartezeit fast 24 Stunden betrug. Wieder wartete ein Patient, der um '2014-01-01 23:59:59' kommt und um '2014-01-02 00:00:01' weggeht für einen Tag, wenn DATEDIFF verwendet wird.

Aber ich schweife ab.

Ich habe DATEDIFF-Lösungen verlassen und diese sogar auf Leistung getestet, aber sie sollten wirklich in ihrer eigenen Liga sein.

Es wurde auch festgestellt, dass es für die großen Datensätze unmöglich ist, Werte am selben Tag zu vermeiden. Wenn wir also 13 Millionen Datensätze aus 2 Jahren Daten haben, werden wir für einige Tage mehr als einen Datensatz haben. Diese Datensätze werden zum frühestmöglichen Zeitpunkt in den DATEDIFF-Lösungen von my und ypercube herausgefiltert. Hoffe, ypercube hat nichts dagegen.

Die Lösungen wurden in der folgenden Tabelle getestet

CREATE TABLE [dbo].[vGetVisits](
    [id] [int] NOT NULL,
    [mydate] [datetime] NOT NULL,
) 

mit zwei verschiedenen Clustered-Indizes (in diesem Fall mydate):

CREATE CLUSTERED INDEX CI_mydate on vGetVisits(mydate) 
GO

Die Tabelle wurde folgendermaßen gefüllt

SET NOCOUNT ON
GO

INSERT INTO dbo.vGetVisits(id, mydate)
VALUES (1, '01/01/1800')
GO

DECLARE @i bigint
SET @i=2

DECLARE @MaxRows bigint
SET @MaxRows=13001

WHILE @i<@MaxRows 
BEGIN
INSERT INTO dbo.vGetVisits(id, mydate)
VALUES (@i, DATEADD(day,FLOOR(Rand()*(3)),(SELECT MAX(mydate) FROM dbo.vGetVisits)))
SET @[email protected]+1
END

Für einen Fall mit mehreren Millionen Zeilen wurde INSERT so geändert, dass zufällig Einträge von 0 bis 20 Minuten hinzugefügt wurden.

Alle Lösungen wurden sorgfältig in den folgenden Code eingepackt

SET NOCOUNT ON
GO

DECLARE @StartDate DATETIME

SET @StartDate = GETDATE()

--- Code goes here

PRINT 'Total milliseconds: ' + CONVERT(varchar, DATEDIFF(ms, @StartDate, GETDATE()))

Geprüfte tatsächliche Codes (in keiner bestimmten Reihenfolge):

Ypercubes DATEDIFF-Lösung ( YPC, DATEDIFF )

DECLARE @cd TABLE
(   TheDate datetime PRIMARY KEY,
    Qualify INT NOT NULL
);

DECLARE
    @TheDate DATETIME,
    @Qualify     INT = 0,
    @PreviousCheckDate DATETIME = '1799-01-01 00:00:00' 


DECLARE c CURSOR
    LOCAL STATIC FORWARD_ONLY READ_ONLY
    FOR
SELECT 
   mydate
FROM 
 (SELECT
       RowNum = ROW_NUMBER() OVER(PARTITION BY cast(mydate as date) ORDER BY mydate)
       , mydate
   FROM 
       dbo.vGetVisits) Actions
WHERE
   RowNum = 1
ORDER BY 
  mydate;

OPEN c ;

FETCH NEXT FROM c INTO @TheDate ;

WHILE @@FETCH_STATUS = 0
BEGIN

    SET @Qualify = CASE WHEN DATEDIFF(day, @PreviousCheckDate, @Thedate) > 90 THEN 1 ELSE 0 END ;
    IF  @Qualify=1
    BEGIN
        INSERT @cd (TheDate, Qualify)
        SELECT @TheDate, @Qualify ;
        SET @[email protected] 
    END
    FETCH NEXT FROM c INTO @TheDate ;
END

CLOSE c;
DEALLOCATE c;


SELECT TheDate
    FROM @cd
    ORDER BY TheDate ;

Ypercubes DATEADD-Lösung ( YPC, DATEADD )

DECLARE @cd TABLE
(   TheDate datetime PRIMARY KEY,
    Qualify INT NOT NULL
);

DECLARE
    @TheDate DATETIME,
    @Next_Date DATETIME,
    @Interesting_Date DATETIME,
    @Qualify     INT = 0

DECLARE c CURSOR
    LOCAL STATIC FORWARD_ONLY READ_ONLY
    FOR
  SELECT 
  [mydate]
  FROM [test].[dbo].[vGetVisits]
  ORDER BY mydate
  ;

OPEN c ;

FETCH NEXT FROM c INTO @TheDate ;

SET @[email protected]

INSERT @cd (TheDate, Qualify)
SELECT @TheDate, @Qualify ;

WHILE @@FETCH_STATUS = 0
BEGIN

    IF @TheDate>DATEADD(DAY, 90, @Interesting_Date)
    BEGIN
        INSERT @cd (TheDate, Qualify)
        SELECT @TheDate, @Qualify ;
        SET @[email protected];
    END

    FETCH NEXT FROM c INTO @TheDate;
END

CLOSE c;
DEALLOCATE c;


SELECT TheDate
    FROM @cd
    ORDER BY TheDate ;

Paul Whites Lösung ( [~ # ~] pw [~ # ~] )

;WITH CTE AS
(
    SELECT TOP (1)
        T.[mydate]
    FROM dbo.vGetVisits AS T
    ORDER BY
        T.[mydate]

    UNION ALL

    SELECT
        SQ1.[mydate]
    FROM 
    (
        SELECT
            T.[mydate],
            rn = ROW_NUMBER() OVER (
                ORDER BY T.[mydate])
        FROM CTE
        JOIN dbo.vGetVisits AS T
            ON T.[mydate] > DATEADD(DAY, 90, CTE.[mydate])
    ) AS SQ1
    WHERE
        SQ1.rn = 1
)

SELECT 
    CTE.[mydate]
FROM CTE
OPTION (MAXRECURSION 0);

Meine DATEADD-Lösung ( PN, DATEADD )

DECLARE @cd TABLE
(   TheDate datetime PRIMARY KEY
);

DECLARE @TheDate DATETIME

SET @TheDate=(SELECT MIN(mydate) as mydate FROM [dbo].[vGetVisits])

WHILE (@TheDate IS NOT NULL)
    BEGIN

        INSERT @cd (TheDate) SELECT @TheDate;

        SET @TheDate=(  
            SELECT MIN(mydate) as mydate 
            FROM [dbo].[vGetVisits]
            WHERE mydate>DATEADD(DAY, 90, @TheDate)
                    )
    END

SELECT TheDate
    FROM @cd
    ORDER BY TheDate ;

Meine DATEDIFF-Lösung ( PN, DATEDIFF )

DECLARE @MinDate DATETIME;
SET @MinDate=(SELECT MIN(mydate) FROM dbo.vGetVisits);
    ;WITH gaps AS
    (
       SELECT 
       t1.[date]
       , t1.[MaxDiff]
       , SUM(t1.[MaxDiff]) OVER (ORDER BY t1.[date]) AS [Running Total]
            FROM
            (
                SELECT 
                mydate AS [date]
                , DATEDIFF(day,LAG(mydate, 1, mydate) OVER (ORDER BY mydate) , mydate) AS [MaxDiff] 
                FROM 
                    (SELECT
                    RowNum = ROW_NUMBER() OVER(PARTITION BY cast(mydate as date) ORDER BY mydate)
                    , mydate
                    FROM dbo.vGetVisits
                    ) Actions
                WHERE RowNum = 1
            ) t1
    )

    SELECT [date]
    FROM gaps t2
    WHERE                         
         ( ([Running Total])%91 - ([Running Total]- [MaxDiff])%91 <0 )      
         OR
         ( [MaxDiff] > 90) 
         OR
         ([date][email protected])    
    ORDER BY [date]

Ich verwende SQL Server 2012, entschuldige mich also bei Mikael Eriksson, aber sein Code wird hier nicht getestet. Ich würde immer noch erwarten, dass seine Lösungen mit DATADIFF und DATEADD für einige Datensätze unterschiedliche Werte zurückgeben.

Und die tatsächlichen Ergebnisse sind: enter image description here

2
Pavel Nefyodov

Ok, habe ich etwas verpasst oder warum würdest du nicht einfach die Rekursion überspringen und dich wieder dir selbst anschließen? Wenn das Datum der Primärschlüssel ist, muss es eindeutig und in chronologischer Reihenfolge sein, wenn Sie den Versatz zur nächsten Zeile berechnen möchten

    DECLARE @T AS TABLE
  (
     TheDate DATETIME PRIMARY KEY
  );

INSERT @T
       (TheDate)
VALUES ('2014-01-01 11:00'),
       ('2014-01-03 10:00'),
       ('2014-01-04 09:30'),
       ('2014-04-01 10:00'),
       ('2014-05-01 11:00'),
       ('2014-07-01 09:00'),
       ('2014-07-31 08:00');

SELECT [T1].[TheDate]                               [first],
       [T2].[TheDate]                               [next],
       Datediff(day, [T1].[TheDate], [T2].[TheDate])[offset],
       ( CASE
           WHEN Datediff(day, [T1].[TheDate], [T2].[TheDate]) >= 30 THEN 1
           ELSE 0
         END )                                      [qualify]
FROM   @T[T1]
       LEFT JOIN @T[T2]
              ON [T2].[TheDate] = (SELECT Min([TheDate])
                                   FROM   @T
                                   WHERE  [TheDate] > [T1].[TheDate]) 

Erträge

enter image description here

Es sei denn, ich habe etwas Wichtiges völlig verpasst ...

0
Sabre