Sql 根据具有排名合同的日期创建历史表（差距和孤岛？）

我在Teradata中遇到了一个问题，我试图构建一个历史合同表，其中列出了一个系统、它对应的合同以及每个合同的开始和结束日期。然后将查询此表，以作为时间点表进行报告。这里有一些代码可以更好地解释

CREATE TABLE TMP_WORK_DB.SOLD_SYSTEMS 
(
SYSTEM_ID varchar(5),
CONTRACT_TYPE varchar(10),
CONTRACT_RANK int,
CONTRACT_STRT_DT date,
CONTRACT_END_DT date
);

INSERT INTO TMP_WORK_DB.SOLD_SYSTEMS  VALUES ('AAA', 'BEST', 10, '2012-01-01', '2012-06-30');
INSERT INTO TMP_WORK_DB.SOLD_SYSTEMS  VALUES ('AAA', 'BEST', 9, '2012-01-01', '2012-06-30');
INSERT INTO TMP_WORK_DB.SOLD_SYSTEMS  VALUES ('AAA', 'OK', 1, '2012-08-01', '2012-12-30');
INSERT INTO TMP_WORK_DB.SOLD_SYSTEMS  VALUES ('BBB', 'BEST', 10, '2013-12-01', '2014-03-02');
INSERT INTO TMP_WORK_DB.SOLD_SYSTEMS  VALUES ('BBB', 'BETTER', 7, '2013-12-01', '2017-03-02');
INSERT INTO TMP_WORK_DB.SOLD_SYSTEMS  VALUES ('BBB', 'GOOD', 4, '2016-12-02', '2017-12-02');
INSERT INTO TMP_WORK_DB.SOLD_SYSTEMS  VALUES ('CCC', 'BEST', 10, '2009-10-13', '2014-10-14');
INSERT INTO TMP_WORK_DB.SOLD_SYSTEMS  VALUES ('CCC', 'BETTER', 7, '2009-10-13', '2016-10-14');
INSERT INTO TMP_WORK_DB.SOLD_SYSTEMS  VALUES ('CCC', 'OK', 2, '2008-10-13', '2017-10-14');

所需的产出将是：

SYSTEM_ID   CONTRACT_TYPE   CONTRACT_STRT_DT    CONTARCT_END_DT     CONTRACT_RANK
  AAA          BEST            01/01/2012          06/30/2012           10
  AAA          OK              08/01/2012          12/30/2012           1
  BBB          BEST            12/01/2013          03/02/2014           10
  BBB          BETTER          03/03/2014          03/02/2017           7
  BBB          GOOD            03/03/2017          12/02/2017           4
  CCC          OK              10/13/2008          10/12/2009           2
  CCC          BEST            10/13/2009          10/14/2014           10
  CCC          BETTER          10/15/2014          10/14/2016           7
  CCC          OK              10/15/2016          10/14/2017           2

我不一定要减少行数，而是希望在任何给定的时间点获得系统id的正确状态。请注意，当排名较高的合同结束，而排名较低的合同仍处于活动状态时，排名较低的合同会在排名较高的合同停止的地方重新开始

我们使用的是TD 14，我已经能够获得日期顺序的简单记录，并且具有更高的等级，但是我在两个不同等级的合同覆盖多个日期跨度的重叠中遇到了问题

我找到了这篇博文（）并使其大部分工作正常，但仍然无法为重叠的合同设置新的开始日期

任何帮助都将不胜感激。谢谢

---

*更新日期：2014年4月4日*

我想出了下面的代码，它给了我想要的东西，但我不确定它的性能。它可以在几百行的较小数据集上工作，但我还没有在几百万行上进行测试：

*更新日期：2014年7月4日* 由于假脱机问题更新了日期子查询。此查询分解合同可能处于活动状态的所有日期，然后使用ROW_NUMBER函数获取每天排名最高的合同类型。然后，在系统和合同类型上划分最小/最大函数，以便在排名最高的合同类型更改时进行选择

*更新-2-2014年7月4日* 我清理了查询，它的性能似乎好了一点

SELECT 
    SYSTEM_ID
,   CONTRACT_TYPE
,   MIN(CALENDAR_DATE) NEW_START_DATE
,   MAX(CALENDAR_DATE) NEW_END_DATE
,   CONTRACT_RANK
FROM (
SELECT 
    CALENDAR_DATE
,   SYSTEM_ID
,   CONTRACT_TYPE
,   CONTRACT_RANK
,   ROW_NUMBER() OVER (PARTITION BY SYSTEM_ID, CALENDAR_DATE ORDER BY CONTRACT_RANK DESC, CONTRACT_STRT_DT DESC, CONTRACT_END_DT DESC) AS RNK
FROM SOLD_SYSTEMS t1
JOIN (
    SELECT CALENDAR_DATE
    FROM FULL_CALENDAR_TABLE ia     
    WHERE CALENDAR_DATE > DATE'2013-01-01'
    )dt
ON CALENDAR_DATE BETWEEN CONTRACT_STRT_DT AND CONTRACT_END_DT
QUALIFY RNK = 1
)z1
GROUP BY 1,2,5

SEL系统id，合同类型，最大值（合同等级），
当合同到期时，我想我已经拿到了。。。。
试试这个

select  SYSTEM_ID, CONTRACT_TYPE,CONTRACT_RANK,
case
    when CONTRACT_STRT_DT<NEW_START_DATE then NEW_START_DATE  /*if new_star_date overlap startdate then get new_Start_date */
    else CONTRACT_STRT_DT
    end as new_contract_str_dt,
     CONTRACT_END_DT
from
(select t1.SYSTEM_ID,t1.CONTRACT_TYPE,t1.CONTRACT_RANK,t1.CONTRACT_STRT_DT,t1.CONTRACT_END_DT,
 coalesce(max(t1.CONTRACT_END_DT) over (partition by t1.SYSTEM_ID  order by t1.CONTRACT_RANK desc rows between UNBOUNDED PRECEDING and 1 preceding  ), t1.CONTRACT_STRT_DT)  NEW_START_DATE
from SOLD_SYSTEMS t1 

) as  temp1
/*you may remove fully overlapped contracts*/
where  NEW_START_DATE<=CONTRACT_END_DT

选择系统ID、合同类型、合同等级、，
案例
当CONTRACT_STRT_DT时，以下方法使用TD13.10中的新周期函数

-- 1. TD_SEQUENCED_COUNT can't be used in joins, so create a Volatile Table
-- 2. TD_SEQUENCED_COUNT can't use additional columns (e.g. CONTRACT_RANK),
--    so simply create a new row whenever a period starts or ends without
--    considering CONTRACT_RANK
CREATE VOLATILE TABLE vt AS
 (
   WITH cte
    (
      SYSTEM_ID
     ,pd
    )
   AS
    (
      SELECT
         SYSTEM_ID
-- PERIODs can easily be constructed on-the-fly, but the end date is not inclusive,
-- so I had to adjust to your implementation, CONTRACT_END_DT +/- 1:
        ,PERIOD(CONTRACT_STRT_DT, CONTRACT_END_DT + 1) AS pd
      FROM SOLD_SYSTEMS
     )
   SELECT
      SYSTEM_ID
     ,BEGIN(pd) AS CONTRACT_STRT_DT
     ,END(pd) - 1 AS CONTRACT_END_DT
   FROM
      TABLE (TD_SEQUENCED_COUNT
            (NEW VARIANT_TYPE(cte.SYSTEM_ID) 
            ,cte.pd) 
      RETURNS (SYSTEM_ID VARCHAR(5)
              ,Policy_Count INTEGER 
              ,pd PERIOD(DATE))
      HASH BY SYSTEM_ID 
      LOCAL ORDER BY SYSTEM_ID ,pd) AS dt
 )
WITH DATA 
PRIMARY INDEX (SYSTEM_ID)
ON COMMIT PRESERVE ROWS
;

-- Find the matching CONTRACT_RANK
SELECT
   vt.SYSTEM_ID
  ,t.CONTRACT_TYPE
  ,vt.CONTRACT_STRT_DT
  ,vt.CONTRACT_END_DT
  ,t.CONTRACT_RANK
FROM vt
-- If both vt and SOLD_SYSTEMS have a NUPI on SYSTEM_ID this join should be
-- quite efficient
JOIN SOLD_SYSTEMS AS t
  ON vt.SYSTEM_ID = t.SYSTEM_ID
 AND      ( t.CONTRACT_STRT_DT,  t.CONTRACT_END_DT)
 OVERLAPS (vt.CONTRACT_STRT_DT, vt.CONTRACT_END_DT)
QUALIFY 
-- As multiple contracts for the same period are possible:
-- find the row with the highest rank
   ROW_NUMBER() 
   OVER (PARTITION BY vt.SYSTEM_ID,vt.CONTRACT_STRT_DT
         ORDER BY t.CONTRACT_RANK DESC, vt.CONTRACT_END_DT DESC) = 1
ORDER BY 1,3
;

-- Previous query might return consecutive rows with the same CONTRACT_RANK, e.g.
-- BBB  BETTER  2014-03-03  2016-12-01  7
-- BBB  BETTER  2016-12-02  2017-03-02  7

-- If you don't want that you have to normalize the data:
WITH cte
 (
   SYSTEM_ID
  ,CONTRACT_STRT_DT
  ,CONTRACT_END_DT
  ,CONTRACT_RANK
  ,CONTRACT_TYPE
  ,pd
 )
AS
 (
   SELECT
      vt.SYSTEM_ID
     ,vt.CONTRACT_STRT_DT
     ,vt.CONTRACT_END_DT
     ,t.CONTRACT_RANK
     ,t.CONTRACT_TYPE
     ,PERIOD(vt.CONTRACT_STRT_DT, vt.CONTRACT_END_DT + 1) AS pd
   FROM vt
   JOIN SOLD_SYSTEMS AS t
     ON vt.SYSTEM_ID = t.SYSTEM_ID
        AND       ( t.CONTRACT_STRT_DT,  t.CONTRACT_END_DT)
         OVERLAPS (vt.CONTRACT_STRT_DT, vt.CONTRACT_END_DT)
   QUALIFY
      ROW_NUMBER() 
      OVER (PARTITION BY vt.SYSTEM_ID,vt.CONTRACT_STRT_DT
            ORDER BY t.CONTRACT_RANK DESC, vt.CONTRACT_END_DT DESC) = 1
 )
SELECT
   SYSTEM_ID
  ,CONTRACT_TYPE
  ,BEGIN(pd) AS CONTRACT_STRT_DT
  ,END(pd) - 1 AS CONTRACT_END_DT
  ,CONTRACT_RANK
FROM
   TABLE (TD_NORMALIZE_MEET
         (NEW VARIANT_TYPE(cte.SYSTEM_ID
                          ,cte.CONTRACT_RANK
                          ,cte.CONTRACT_TYPE)
         ,cte.pd) 
   RETURNS (SYSTEM_ID VARCHAR(5)
           ,CONTRACT_RANK INT
           ,CONTRACT_TYPE VARCHAR(10)
           ,pd PERIOD(DATE))
   HASH BY SYSTEM_ID 
   LOCAL ORDER BY SYSTEM_ID, CONTRACT_RANK, CONTRACT_TYPE, pd ) A
ORDER BY 1, 3;

编辑：这是获得第二次查询结果的另一种方法，无需Volatile Table和TD_SEQUENCED_COUNT：

SELECT
   t.SYSTEM_ID
  ,t.CONTRACT_TYPE
  ,BEGIN(CONTRACT_PERIOD)  AS CONTRACT_STRT_DT
  ,END(CONTRACT_PERIOD)- 1 AS CONTRACT_END_DT
  ,t.CONTRACT_RANK
  ,dt.p P_INTERSECT PERIOD(t.CONTRACT_STRT_DT,t.CONTRACT_END_DT + 1) AS CONTRACT_PERIOD
FROM
 (
   SELECT
      dt.SYSTEM_ID
     ,PERIOD(d, MIN(d)
                OVER (PARTITION BY dt.SYSTEM_ID
                      ORDER BY d
                      ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING)) AS p
   FROM
    (
      SELECT
         SYSTEM_ID
        ,CONTRACT_STRT_DT AS d
      FROM SOLD_SYSTEMS
      UNION
      SELECT
         SYSTEM_ID
        ,CONTRACT_END_DT + 1 AS d
      FROM SOLD_SYSTEMS
    ) AS dt 
    QUALIFY p IS NOT NULL
 ) AS dt
JOIN SOLD_SYSTEMS AS t
  ON dt.SYSTEM_ID = t.SYSTEM_ID
WHERE CONTRACT_PERIOD IS NOT NULL
QUALIFY 
   ROW_NUMBER() 
   OVER (PARTITION BY dt.SYSTEM_ID,p
         ORDER BY t.CONTRACT_RANK DESC, t.CONTRACT_END_DT DESC) = 1
ORDER BY 1,3

基于此，您还可以在单个查询中包含规范化：

WITH cte
 (
   SYSTEM_ID
  ,CONTRACT_TYPE
  ,CONTRACT_STRT_DT
  ,CONTRACT_END_DT
  ,CONTRACT_RANK
  ,pd
 )
AS
 (
   SELECT
      t.SYSTEM_ID
     ,t.CONTRACT_TYPE
     ,BEGIN(CONTRACT_PERIOD)  AS CONTRACT_STRT_DT
     ,END(CONTRACT_PERIOD)- 1 AS CONTRACT_END_DT
     ,t.CONTRACT_RANK
     ,dt.p P_INTERSECT PERIOD(t.CONTRACT_STRT_DT,t.CONTRACT_END_DT + 1) AS CONTRACT_PERIOD
   FROM
    (
      SELECT
         dt.SYSTEM_ID
        ,PERIOD(d, MIN(d)
                   OVER (PARTITION BY dt.SYSTEM_ID
                         ORDER BY d
                         ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING)) AS p
      FROM
       (
         SELECT
            SYSTEM_ID
           ,CONTRACT_STRT_DT AS d
         FROM SOLD_SYSTEMS
         UNION
         SELECT
            SYSTEM_ID
           ,CONTRACT_END_DT + 1 AS d
         FROM SOLD_SYSTEMS
       ) AS dt 
       QUALIFY p IS NOT NULL
    ) AS dt
   JOIN SOLD_SYSTEMS AS t
     ON dt.SYSTEM_ID = t.SYSTEM_ID
   WHERE CONTRACT_PERIOD IS NOT NULL
   QUALIFY 
      ROW_NUMBER() 
      OVER (PARTITION BY dt.SYSTEM_ID,p
            ORDER BY t.CONTRACT_RANK DESC, t.CONTRACT_END_DT DESC) = 1
 )
SELECT
   SYSTEM_ID
  ,CONTRACT_TYPE
  ,BEGIN(pd) AS CONTRACT_STRT_DT
  ,END(pd) - 1 AS CONTRACT_END_DT
  ,CONTRACT_RANK
FROM 
   TABLE (TD_NORMALIZE_MEET
         (NEW VARIANT_TYPE(cte.SYSTEM_ID
                          ,cte.CONTRACT_RANK
                          ,cte.CONTRACT_TYPE)
         ,cte.pd) 
   RETURNS (SYSTEM_ID VARCHAR(5)
           ,CONTRACT_RANK INT
           ,CONTRACT_TYPE VARCHAR(10)
           ,pd PERIOD(DATE))
   HASH BY SYSTEM_ID 
   LOCAL ORDER BY SYSTEM_ID, CONTRACT_RANK, CONTRACT_TYPE, pd ) A
ORDER BY 1, 3;

那真的不起作用。它以步进顺序创建了新日期，但新的开始日期有时大于结束日期和上一个结束日期。但在同一查询中执行上一个查询时，您给了我一些新的想法。@WrstCodeRever查询已编辑，请告诉我用例失败。感谢这仍然不起作用，因为它留下了不应该包括的较低级别的部分。当每个日期范围都是唯一的并且每个系统id只有一个排名靠前的合同类型时，数据需要尽可能地流动。我确实更改了该子查询，因为它正在后台处理<代码>更新的代码
来自售出的系统t1
加入（
从完整的日历表ia中选择日历日期
，其中日历日期>日期'2005-01-01'
）dt
在合同开始日期和合同结束日期之间的日历日期
基本上，我需要一个表格，其中包含每个合同有效期的排名最高的合同类型。系统可以同时激活多个合同类型，但我们只想显示排名最高的活动合同是什么。系统AAA是一个简单的案例，因为没有重叠。系统BBB有3个重叠的合同。因此，从2013年12月1日到2014年3月2日，排名最高的是“最好的”，同时也有更好的，但排名较低，因此直到2014年3月3日才会考虑。好的合同在更好的结果之后被认为是排名最高的，从2017年3月3日到2017年12月2日，这有意义吗？我们正在努力完成两件事。一种是合并重叠日期，另一种是在合同期限内给出排名最高的合同。最终结果将是一个表格，我们可以查询
从SYS\u CONTARCT\u HIST中选择合同类型，其中日期为'2014-12-05'，在NEW\u STRT\u DT和NEW\u end\u DT之间
我想您可能有一些信息。起初它排除了我需要的一些记录，但我修改了partition语句以获得丢失的日期<代码>合并（最大值（t1.CONTRACT\u END\u DT）超过（按t1.SYSTEM\u ID、CONTRACT\u STRT\u DT划分）
我使用此条件“无界前一行和前一行之间的行”来获取以前合同的最大日期（当您从选择中删除完全重叠的合同时，它是有用的）。我希望我的答案是有用的。在这段时间内，每天将数据分解为一行也可以使用EXPAND ON来完成，但最终可能会出现一个巨大的假脱机。您需要编写一个查询来获得该结果吗？或者使用易变表的两步过程也可以吗？我有一个类似的问题，我可以重写…您说得对分解数据需要一个巨大的假脱机。我可以使用尽可能多的步骤和任何方法来完成此操作。来自@rpc1的答案很接近，但仍然存在未选择正确结束日期的情况。我目前正在尝试解决此问题。我清理了
创建表
和
插入
数据统计我想用@dnoeth的解决方案提供一个完全有效的解决方案。太棒了。哇。@dnoeth这很好用。你应该得到一杯啤酒，或者更好的是一整桶。；-）我读过关于新时期数据类型的文章，但不知道它会让这样的问题看起来如此简单。我想当你像你一样是TD大师的时候，它会有所帮助。谢谢。我希望你不介意，但我修正了
系统ID VARCHAR（5）
列数据长度，因此它将是一个供其他人使用的完全有效的示例。（如果主持人允许编辑）再次感谢。
WITH cte
 (
   SYSTEM_ID
  ,CONTRACT_TYPE
  ,CONTRACT_STRT_DT
  ,CONTRACT_END_DT
  ,CONTRACT_RANK
  ,pd
 )
AS
 (
   SELECT
      t.SYSTEM_ID
     ,t.CONTRACT_TYPE
     ,BEGIN(CONTRACT_PERIOD)  AS CONTRACT_STRT_DT
     ,END(CONTRACT_PERIOD)- 1 AS CONTRACT_END_DT
     ,t.CONTRACT_RANK
     ,dt.p P_INTERSECT PERIOD(t.CONTRACT_STRT_DT,t.CONTRACT_END_DT + 1) AS CONTRACT_PERIOD
   FROM
    (
      SELECT
         dt.SYSTEM_ID
        ,PERIOD(d, MIN(d)
                   OVER (PARTITION BY dt.SYSTEM_ID
                         ORDER BY d
                         ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING)) AS p
      FROM
       (
         SELECT
            SYSTEM_ID
           ,CONTRACT_STRT_DT AS d
         FROM SOLD_SYSTEMS
         UNION
         SELECT
            SYSTEM_ID
           ,CONTRACT_END_DT + 1 AS d
         FROM SOLD_SYSTEMS
       ) AS dt 
       QUALIFY p IS NOT NULL
    ) AS dt
   JOIN SOLD_SYSTEMS AS t
     ON dt.SYSTEM_ID = t.SYSTEM_ID
   WHERE CONTRACT_PERIOD IS NOT NULL
   QUALIFY 
      ROW_NUMBER() 
      OVER (PARTITION BY dt.SYSTEM_ID,p
            ORDER BY t.CONTRACT_RANK DESC, t.CONTRACT_END_DT DESC) = 1
 )
SELECT
   SYSTEM_ID
  ,CONTRACT_TYPE
  ,BEGIN(pd) AS CONTRACT_STRT_DT
  ,END(pd) - 1 AS CONTRACT_END_DT
  ,CONTRACT_RANK
FROM 
   TABLE (TD_NORMALIZE_MEET
         (NEW VARIANT_TYPE(cte.SYSTEM_ID
                          ,cte.CONTRACT_RANK
                          ,cte.CONTRACT_TYPE)
         ,cte.pd) 
   RETURNS (SYSTEM_ID VARCHAR(5)
           ,CONTRACT_RANK INT
           ,CONTRACT_TYPE VARCHAR(10)
           ,pd PERIOD(DATE))
   HASH BY SYSTEM_ID 
   LOCAL ORDER BY SYSTEM_ID, CONTRACT_RANK, CONTRACT_TYPE, pd ) A
ORDER BY 1, 3;