Consulta sem WHILE Loop

Temos tabela de compromissos, como mostrado abaixo. Cada compromisso precisa ser categorizado como "Novo" ou "Acompanhamento". Qualquer consulta (para um paciente) dentro de 30 dias da primeira consulta (desse paciente) é Acompanhamento. Após 30 dias, a nomeação é novamente "Nova". Qualquer compromisso dentro de 30 dias se torna "Acompanhamento".

Atualmente, estou fazendo isso digitando while loop.
Como conseguir isso sem o loop WHILE?

Mesa

CREATE TABLE #Appt1 (ApptID INT, PatientID INT, ApptDate DATE)
INSERT INTO #Appt1
SELECT  1,101,'2020-01-05' UNION
SELECT  2,505,'2020-01-06' UNION
SELECT  3,505,'2020-01-10' UNION
SELECT  4,505,'2020-01-20' UNION
SELECT  5,101,'2020-01-25' UNION
SELECT  6,101,'2020-02-12'  UNION
SELECT  7,101,'2020-02-20'  UNION
SELECT  8,101,'2020-03-30'  UNION
SELECT  9,303,'2020-01-28' UNION
SELECT  10,303,'2020-02-02' 

Você precisa usar a consulta recursiva.

O período de 30 dias é contado a partir de anterior (e não, não é possível fazê-lo sem recursão / atualização / loop peculiar). É por isso que toda a resposta existente usando apenas ROW_NUMBERfalhou.

WITH f AS (
  SELECT *, rn = ROW_NUMBER() OVER(PARTITION BY PatientId ORDER BY ApptDate) 
  FROM Appt1
), rec AS (
  SELECT Category = CAST('New' AS NVARCHAR(20)), ApptId, PatientId, ApptDate, rn, startDate = ApptDate
  FROM f
  WHERE rn = 1
  UNION ALL
  SELECT CAST(CASE WHEN DATEDIFF(DAY,  rec.startDate,f.ApptDate) <= 30 THEN N'FollowUp' ELSE N'New' END AS NVARCHAR(20)), 
         f.ApptId,f.PatientId,f.ApptDate, f.rn,
         CASE WHEN DATEDIFF(DAY, rec.startDate, f.ApptDate) <= 30 THEN rec.startDate ELSE f.ApptDate END
  FROM rec
  JOIN f
    ON rec.rn = f.rn - 1
   AND rec.PatientId = f.PatientId
)
SELECT ApptId, PatientId, ApptDate, Category
FROM rec
ORDER BY PatientId, ApptDate;  

db <> demo de violino

Resultado:

+---------+------------+-------------+----------+
| ApptId  | PatientId  |  ApptDate   | Category |
+---------+------------+-------------+----------+
|      1  |       101  | 2020-01-05  | New      |
|      5  |       101  | 2020-01-25  | FollowUp |
|      6  |       101  | 2020-02-12  | New      |
|      7  |       101  | 2020-02-20  | FollowUp |
|      8  |       101  | 2020-03-30  | New      |
|      9  |       303  | 2020-01-28  | New      |
|     10  |       303  | 2020-02-02  | FollowUp |
|      2  |       505  | 2020-01-06  | New      |
|      3  |       505  | 2020-01-10  | FollowUp |
|      4  |       505  | 2020-01-20  | FollowUp |
+---------+------------+-------------+----------+

Como funciona:

1. f - obter ponto de partida (âncora - por cada PatientId)
2. rec - recursibe parte, se a diferença entre o valor atual e o anterior for> 30, altere a categoria e o ponto inicial, no contexto de PatientId
3. Principal - exibe o conjunto de resultados classificados

Classe semelhante:

Soma Condicional no Oracle - Limpando uma Função de Janela

Janela de sessão (Azure Stream Analytics)

Total em execução até que a condição específica seja verdadeira - Atualização peculiar

Termo aditivo

Nunca use esse código na produção!

Mas outra opção, que vale a pena mencionar, além de usar cte, é usar a tabela temporária e atualizar em "rodadas"

Isso poderia ser feito na rodada "única" (atualização peculiar):

CREATE TABLE Appt_temp (ApptID INT , PatientID INT, ApptDate DATE, Category NVARCHAR(10))

INSERT INTO Appt_temp(ApptId, PatientId, ApptDate)
SELECT ApptId, PatientId, ApptDate
FROM Appt1;

CREATE CLUSTERED INDEX Idx_appt ON Appt_temp(PatientID, ApptDate);

Inquerir:

DECLARE @PatientId INT = 0,
        @PrevPatientId INT,
        @FirstApptDate DATE = NULL;

UPDATE Appt_temp
SET  @PrevPatientId = @PatientId
    ,@PatientId     = PatientID 
    ,@FirstApptDate = CASE WHEN @PrevPatientId <> @PatientId THEN ApptDate
                           WHEN DATEDIFF(DAY, @FirstApptDate, ApptDate)>30 THEN ApptDate
                           ELSE @FirstApptDate
                      END
    ,Category       = CASE WHEN @PrevPatientId <> @PatientId THEN 'New'
                           WHEN @FirstApptDate = ApptDate THEN 'New'
                           ELSE 'FollowUp' 
                      END
FROM Appt_temp WITH(INDEX(Idx_appt))
OPTION (MAXDOP 1);

SELECT * FROM  Appt_temp ORDER BY PatientId, ApptDate;

atualização quirky do violino do db <>

Você poderia fazer isso com um cte recursivo. Você deve primeiro solicitar por apptDate em cada paciente. Isso pode ser conseguido por meio de um CTE comum.

Em seguida, na parte âncora do seu recursivo, selecione a primeira ordem para cada paciente, marque o status como 'novo' e marque apptDate como a data do 'novo' registro mais recente.

Na parte recursiva do cte recursivo, aumente para o próximo compromisso, calcule a diferença de dias entre o presente e a mais recente data do novo compromisso. Se for superior a 30 dias, marque-o como 'novo' e redefina a data do novo compromisso mais recente. Caso contrário, marque-o como "acompanhamento" e passe apenas os dias existentes desde a nova data do compromisso.

Por fim, na consulta base, basta selecionar as colunas que deseja.

with orderings as (

    select       *, 
                 rn = row_number() over(
                     partition by patientId 
                     order by apptDate
                 ) 
    from         #appt1 a

),

markings as (

    select       apptId, 
                 patientId, 
                 apptDate, 
                 rn, 
                 type = convert(varchar(10),'new'),
                 dateOfNew = apptDate
    from         orderings 
    where        rn = 1

    union all
    select       o.apptId, o.patientId, o.apptDate, o.rn,
                 type = convert(varchar(10),iif(ap.daysSinceNew > 30, 'new', 'follow up')),
                 dateOfNew = iif(ap.daysSinceNew > 30, o.apptDate, m.dateOfNew)
    from         markings m
    join         orderings o 
                     on m.patientId = o.patientId 
                     and m.rn + 1 = o.rn
    cross apply  (select daysSinceNew = datediff(day, m.dateOfNew, o.apptDate)) ap

)

select    apptId, patientId, apptDate, type
from      markings
order by  patientId, rn;

Devo mencionar que, inicialmente, excluí esta resposta porque a resposta de Abhijeet Khandagale parecia atender às suas necessidades com uma consulta mais simples (depois de reformulá-la um pouco). Mas, com seu comentário sobre seus requisitos de negócios e seus dados de amostra adicionados, cancelei a exclusão dos meus porque acredito que este atenda às suas necessidades.

Não tenho certeza de que é exatamente o que você implementou. Mas outra opção, que vale a pena mencionar, além de usar o cte, é usar a tabela temporária e atualizar em "rodadas". Então, vamos atualizar a tabela temporária enquanto todos os status não estiverem definidos corretamente e criar o resultado de maneira iterativa. Podemos controlar o número de iterações usando simplesmente variáveis ​​locais.

Então, dividimos cada iteração em dois estágios.

1. Defina todos os valores de acompanhamento próximos a novos registros. É muito fácil fazer isso usando o filtro certo.
2. Nos demais registros que não possuem status definido, podemos selecionar primeiro o grupo com o mesmo PatientID. E diga que eles são novos, pois não foram processados ​​no primeiro estágio.

assim

CREATE TABLE #Appt2 (ApptID INT, PatientID INT, ApptDate DATE, AppStatus nvarchar(100))

select * from #Appt1
insert into #Appt2 (ApptID, PatientID, ApptDate, AppStatus)
select a1.ApptID, a1.PatientID, a1.ApptDate, null from #Appt1 a1
declare @limit int = 0;

while (exists(select * from #Appt2 where AppStatus IS NULL) and @limit < 1000)
begin
  set @limit = @limit+1;
  update a2
  set
    a2.AppStatus = IIF(exists(
        select * 
        from #Appt2 a 
        where 
          0 > DATEDIFF(day, a2.ApptDate, a.ApptDate) 
          and DATEDIFF(day, a2.ApptDate, a.ApptDate) > -30 
          and a.ApptID != a2.ApptID 
          and a.PatientID = a2.PatientID
          and a.AppStatus = 'New'
          ), 'Followup', a2.AppStatus)
  from #Appt2 a2

  --select * from #Appt2

  update a2
  set a2.AppStatus = 'New'
  from #Appt2 a2 join (select a.*, ROW_NUMBER() over (Partition By PatientId order by ApptId) rn from (select * from #Appt2 where AppStatus IS NULL) a) ar
  on a2.ApptID = ar.ApptID
  and ar.rn = 1

  --select * from #Appt2

end

select * from #Appt2 order by PatientID, ApptDate

drop table #Appt1
drop table #Appt2

Atualizar. Leia o comentário fornecido por Lukasz. É de maneira muito mais inteligente. Deixo minha resposta apenas como uma ideia.

Acredito que a expressão comum recursiva é uma ótima maneira de otimizar consultas, evitando loops, mas em alguns casos pode levar a um desempenho ruim e deve ser evitada, se possível.

Uso o código abaixo para resolver o problema e testá-lo com mais valores, mas encorajo você a testá-lo com seus dados reais também.

WITH DataSource AS
(
    SELECT *
          ,CEILING(DATEDIFF(DAY, MIN([ApptDate]) OVER (PARTITION BY [PatientID]), [ApptDate]) * 1.0 / 30 + 0.000001) AS [GroupID]
    FROM #Appt1
)
SELECT *
     ,IIF(ROW_NUMBER() OVER (PARTITION BY [PatientID], [GroupID] ORDER BY [ApptDate]) = 1, 'New', 'Followup')
FROM DataSource
ORDER BY [PatientID]
        ,[ApptDate];

A ideia é bem simples - quero separar os registros em grupo (30 dias), em qual grupo o menor é o registro newe os outros follow ups. Verifique como a declaração é criada:

SELECT *
      ,DATEDIFF(DAY, MIN([ApptDate]) OVER (PARTITION BY [PatientID]), [ApptDate])
      ,DATEDIFF(DAY, MIN([ApptDate]) OVER (PARTITION BY [PatientID]), [ApptDate]) * 1.0 / 30
      ,CEILING(DATEDIFF(DAY, MIN([ApptDate]) OVER (PARTITION BY [PatientID]), [ApptDate]) * 1.0 / 30 + 0.000001) 
FROM #Appt1
ORDER BY [PatientID]
        ,[ApptDate];

Assim:

1. primeiro, estamos obtendo a primeira data, para cada grupo e calculando as diferenças em dias com a atual
2. então, queremos obter grupos - * 1.0 / 30é adicionado
3. quanto a 30, 60, 90, etc dias, estamos obtendo um número inteiro e queríamos iniciar um novo período, acrescentei + 0.000001; Além disso, estamos usando a função de teto para obter osmallest integer greater than, or equal to, the specified numeric expression

É isso aí. Tendo esse grupo, simplesmente usamos ROW_NUMBERpara encontrar nossa data de início e torná-la como newe deixando o resto como follow ups.

Com o devido respeito a todos e no IMHO,

There is not much difference between While LOOP and Recursive CTE in terms of RBAR

Não há muito ganho de desempenho ao usar Recursive CTEe Window Partition functiontudo em um.

Appiddeveria ser int identity(1,1), ou deveria estar sempre aumentando clustered index.

Além de outros benefícios, também garante que todas as filas sucessivas APPDatedesse paciente sejam maiores.

Dessa forma, você pode facilmente brincar com APPIDsua consulta, o que será mais eficiente do que colocar o inequalityoperador como>, <em APPDate. Colocar o inequalityoperador como>, <no APPID ajudará o Sql Optimizer.

Também deve haver duas colunas de data na tabela como

APPDateTime datetime2(0) not null,
Appdate date not null

Como essas são as colunas mais importantes da tabela mais importante, então não muito elenco, converta.

Então Non clustered indexpode ser criado no Appdate

Create NonClustered index ix_PID_AppDate_App  on APP (patientid,APPDate) include(other column which is not i predicate except APPID)

Teste meu script com outros dados de amostra e deixe-me saber para quais dados de amostra ele não está funcionando. Mesmo que não funcione, tenho certeza de que pode ser corrigido na minha própria lógica de script.

CREATE TABLE #Appt1 (ApptID INT, PatientID INT, ApptDate DATE)
INSERT INTO #Appt1
SELECT  1,101,'2020-01-05'  UNION ALL
SELECT  2,505,'2020-01-06'  UNION ALL
SELECT  3,505,'2020-01-10'  UNION ALL
SELECT  4,505,'2020-01-20'  UNION ALL
SELECT  5,101,'2020-01-25'  UNION ALL
SELECT  6,101,'2020-02-12'  UNION ALL
SELECT  7,101,'2020-02-20'  UNION ALL
SELECT  8,101,'2020-03-30'  UNION ALL
SELECT  9,303,'2020-01-28'  UNION ALL
SELECT  10,303,'2020-02-02' 

;With CTE as
(
select a1.* ,a2.ApptDate as NewApptDate
from #Appt1 a1
outer apply(select top 1 a2.ApptID ,a2.ApptDate
from #Appt1 A2 
where a1.PatientID=a2.PatientID and a1.ApptID>a2.ApptID 
and DATEDIFF(day,a2.ApptDate, a1.ApptDate)>30
order by a2.ApptID desc )A2
)
,CTE1 as
(
select a1.*, a2.ApptDate as FollowApptDate
from CTE A1
outer apply(select top 1 a2.ApptID ,a2.ApptDate
from #Appt1 A2 
where a1.PatientID=a2.PatientID and a1.ApptID>a2.ApptID 
and DATEDIFF(day,a2.ApptDate, a1.ApptDate)<=30
order by a2.ApptID desc )A2
)
select  * 
,case when FollowApptDate is null then 'New' 
when NewApptDate is not null and FollowApptDate is not null 
and DATEDIFF(day,NewApptDate, FollowApptDate)<=30 then 'New'
else 'Followup' end
 as Category
from cte1 a1
order by a1.PatientID

drop table #Appt1

Embora não esteja claramente abordado na pergunta, é fácil descobrir que as datas dos compromissos não podem ser simplesmente categorizadas por grupos de 30 dias. Não faz sentido nos negócios. E você também não pode usar o ID do agendamento. Pode-se marcar uma nova consulta hoje para2020-09-06. Aqui está como eu resolvo esse problema. Primeiro, obtenha o primeiro compromisso e calcule a diferença de data entre cada compromisso e o primeiro agendamento. Se for 0, defina como 'Novo'. Se <= 30 'Acompanhamento'. Se> 30, defina como 'Indeciso' e faça a próxima rodada até que não haja mais 'Indeciso'. E para isso, você realmente precisa de um loop while, mas ele não percorre a data de cada compromisso, apenas alguns conjuntos de dados. Eu verifiquei o plano de execução. Embora existam apenas 10 linhas, o custo da consulta é significativamente menor que o do CTE recursivo, mas não tão baixo quanto o método de adendo de Lukasz Szozda.

IF OBJECT_ID('tempdb..#TEMPTABLE') IS NOT NULL DROP TABLE #TEMPTABLE
SELECT ApptID, PatientID, ApptDate
    ,CASE WHEN (DATEDIFF(DAY, MIN(ApptDate) OVER (PARTITION BY PatientID), ApptDate) = 0) THEN 'New' 
    WHEN (DATEDIFF(DAY, MIN(ApptDate) OVER (PARTITION BY PatientID), ApptDate) <= 30) THEN 'Followup'
    ELSE 'Undecided' END AS Category
INTO #TEMPTABLE
FROM #Appt1

WHILE EXISTS(SELECT TOP 1 * FROM #TEMPTABLE WHERE Category = 'Undecided') BEGIN
    ;WITH CTE AS (
        SELECT ApptID, PatientID, ApptDate 
            ,CASE WHEN (DATEDIFF(DAY, MIN(ApptDate) OVER (PARTITION BY PatientID), ApptDate) = 0) THEN 'New' 
            WHEN (DATEDIFF(DAY, MIN(ApptDate) OVER (PARTITION BY PatientID), ApptDate) <= 30) THEN 'Followup'
            ELSE 'Undecided' END AS Category    
        FROM #TEMPTABLE
        WHERE Category = 'Undecided'
    )
    UPDATE #TEMPTABLE
    SET Category = CTE.Category
    FROM #TEMPTABLE t
        LEFT JOIN CTE ON CTE.ApptID = t.ApptID
    WHERE t.Category = 'Undecided'
END

SELECT ApptID, PatientID, ApptDate, Category 
FROM #TEMPTABLE

Eu espero que isso te ajude.

WITH CTE AS
(
    SELECT #Appt1.*, RowNum = ROW_NUMBER() OVER (PARTITION BY PatientID ORDER BY ApptDate, ApptID) FROM #Appt1
)

SELECT A.ApptID , A.PatientID , A.ApptDate ,
Expected_Category = CASE WHEN (DATEDIFF(MONTH, B.ApptDate, A.ApptDate) > 0) THEN 'New' 
WHEN (DATEDIFF(DAY, B.ApptDate, A.ApptDate) <= 30) then 'Followup' 
ELSE 'New' END
FROM CTE A
LEFT OUTER JOIN CTE B on A.PatientID = B.PatientID 
AND A.rownum = B.rownum + 1
ORDER BY A.PatientID, A.ApptDate

Você poderia usar uma Casedeclaração .

select 
      *, 
      CASE 
          WHEN DATEDIFF(d,A1.ApptDate,A2.ApptDate)>30 THEN 'New' 
          ELSE 'FollowUp' 
      END 'Category'
from 
      (SELECT PatientId, MIN(ApptId) 'ApptId', MIN(ApptDate) 'ApptDate' FROM #Appt1 GROUP BY PatientID)  A1, 
      #Appt1 A2 
where 
     A1.PatientID=A2.PatientID AND A1.ApptID<A2.ApptID

A questão é: essa categoria deve ser atribuída com base no compromisso inicial ou no anterior? Ou seja, se um paciente teve três consultas, devemos comparar a terceira consulta com a primeira ou a segunda?

Seu problema declara o primeiro, e foi assim que eu respondi. Se não for esse o caso, convém usar lag.

Além disso, lembre-se de que isso DateDiffnão é exceção nos finais de semana. Se for apenas durante a semana, você precisará criar sua própria função com valor escalar.

usando a função Lag

select  apptID, PatientID , Apptdate ,  
    case when date_diff IS NULL THEN 'NEW' 
         when date_diff < 30 and (date_diff_2 IS NULL or date_diff_2 < 30) THEN  'Follow Up'
         ELSE 'NEW'
    END AS STATUS FROM 
(
select 
apptID, PatientID , Apptdate , 
DATEDIFF (day,lag(Apptdate) over (PARTITION BY PatientID order by ApptID asc),Apptdate) date_diff ,
DATEDIFF(day,lag(Apptdate,2) over (PARTITION BY PatientID order by ApptID asc),Apptdate) date_diff_2
  from #Appt1
) SRC

Demonstração -> https://rextester.com/TNW43808

with cte
as
(
select 
tmp.*, 
IsNull(Lag(ApptDate) Over (partition by PatientID Order by  PatientID,ApptDate),ApptDate) PriorApptDate
 from #Appt1 tmp
)
select 
PatientID, 
ApptDate, 
PriorApptDate, 
DateDiff(d,PriorApptDate,ApptDate) Elapsed,
Case when DateDiff(d,PriorApptDate,ApptDate)>30 
or DateDiff(d,PriorApptDate,ApptDate)=0 then 'New' else 'Followup'   end Category   from cte

O meu está correto. Os autores estavam incorretos.