使用重复键在 data.table 上滚动连接

Question

我正在尝试了解data.table rolling joins 。 最后给出了重现这一点的数据。

给定一个指定时间在机场的交易数据表：

> dt
   t_id airport thisTime
1:    1       a      5.1
2:    3       a      5.1
3:    2       a      6.2  

（注意t_ids 1 和 3 具有相同的机场和时间）

以及从机场起飞的航班查找表：

> dt_lookup
   f_id airport thisTime
1:    1       a        6
2:    2       a        6
3:    1       b        7
4:    1       c        8
5:    2       d        7
6:    1       d        9
7:    2       e        8

> tables()
     NAME      NROW NCOL MB COLS                  KEY             
[1,] dt           3    3  1 t_id,airport,thisTime airport,thisTime
[2,] dt_lookup    7    3  1 f_id,airport,thisTime airport,thisTime

我想将所有交易与从该机场起飞的所有下一个可能的航班相匹配，以给出：

   t_id airport thisTime f_id
      1       a        6    1
      1       a        6    2
      3       a        6    1
      3       a        6    2

所以我认为这会奏效：

> dt[dt_lookup, nomatch=0,roll=Inf]
   t_id airport thisTime f_id
1:    3       a        6    1
2:    3       a        6    2

但它没有返回交易t_id == 1 。

从文档中它说：

通常，x 的键中不应有重复项，...

但是，我的“x 键”（即airport和thisTime ）中确实有重复项，并且无法完全看到/理解发生了什么意味着从输出中删除了t_id = 1 。

任何人都可以解释为什么不返回t_id = 1 ，以及当我有重复项时如何让连接工作？

数据

library(data.table)
dt <- data.table(t_id = seq(1:3),
                 airport = c("a","a","a"),
                 thisTime = c(5.1,6.2, 5.1), key=c( "airport","thisTime"))

dt_lookup <- data.table(f_id = c(rep(1,4),rep(2,3)),
                        airport = c("a","b","c","d",
                                 "a","d","e"),
                        thisTime = c(6,7,8,9,
                                 6,7,8), key=c("airport","thisTime"))

Answer 1

t_id = 1没有出现在输出中的原因是因为滚动连接采用了最后出现键组合的行。 从文档（强调我的）：

适用于最后一个连接列，通常是日期，但可以是任何有序变量、不规则和包括间隙。 如果 roll=TRUE 并且 i 的行与除最后一个 x 连接列之外的所有列都匹配，并且它在最后一个 i 连接列中的值落在一个间隙中（包括在 x 中对该组的最后一次观察之后），则 x 中的主要值为向前滚动。 使用修改后的二进制搜索，此操作特别快。 该操作也称为最后一次观察结转 (LOCF)。

让我们考虑更大的数据集：

> DT
   t_id airport thisTime
1:    1       a      5.1
2:    4       a      5.1
3:    3       a      5.1
4:    2       d      6.2
5:    5       d      6.2

> DT_LU
   f_id airport thisTime
1:    1       a        6
2:    2       a        6
3:    2       a        8
4:    1       b        7
5:    1       c        8
6:    2       d        7
7:    1       d        9

当您执行滚动连接时，就像您的问题一样：

DT[DT_LU, nomatch=0, roll=Inf]

你得到：

 t_id airport thisTime f_id 1: 3 a 6 1 2: 3 a 6 2 3: 3 a 8 2 4: 5 d 7 2 5: 5 d 9 1

如您所见，从组合键a, 5.1和d, 6.2 ，最后一行用于连接的数据表。 因为您使用Inf作为滚动值，所以所有未来值都包含在结果数据表中。 当您使用：

DT[DT_LU, nomatch=0, roll=1]

您会看到只包含未来的第一个值：

 t_id airport thisTime f_id 1: 3 a 6 1 2: 3 a 6 2 3: 5 d 7 2

---

如果你想f_id的为的所有组合airport和thisTime其中DT$thisTime低于DT_LU$thisTime ，你可以通过创建一个新的变量（或替换现有实现这一thisTime ）由手段ceiling功能。 在这里我创建了一个新变量的一个例子thisTime2 ，然后做一个正常的加入DT_LU ：

DT[, thisTime2 := ceiling(thisTime)]
setkey(DT, airport, thisTime2)[DT_LU, nomatch=0]

这使：

 t_id airport thisTime thisTime2 f_id 1: 1 a 5.1 6 1 2: 4 a 5.1 6 1 3: 3 a 5.1 6 1 4: 1 a 5.1 6 2 5: 4 a 5.1 6 2 6: 3 a 5.1 6 2 7: 2 d 6.2 7 2 8: 5 d 6.2 7 2

应用于您提供的数据：

 > dt[, thisTime2 := ceiling(thisTime)] > setkey(dt, airport, thisTime2)[dt_lookup, nomatch=0] t_id airport thisTime thisTime2 f_id 1: 1 a 5.1 6 1 2: 3 a 5.1 6 1 3: 1 a 5.1 6 2 4: 3 a 5.1 6 2

---

当您想包含所有未来值而不是仅包含第一个值时，您需要一种稍微不同的方法，您将需要i.col功能（尚未记录）：

1 ：首先将键设置为仅airport列：

setkey(DT, airport)
setkey(DT_LU, airport)

2 ：在j使用i.col功能（尚未记录）来获得您想要的内容，如下所示：

DT1 <- DT_LU[DT, .(tid = i.t_id,
                   tTime = i.thisTime,
                   fTime = thisTime[i.thisTime < thisTime],
                   fid = f_id[i.thisTime < thisTime]),
             by=.EACHI]

这给你：

 > DT1 airport tid tTime fTime fid 1: a 1 5.1 6 1 2: a 1 5.1 6 2 3: a 1 5.1 8 2 4: a 4 5.1 6 1 5: a 4 5.1 6 2 6: a 4 5.1 8 2 7: a 3 5.1 6 1 8: a 3 5.1 6 2 9: a 3 5.1 8 2 10: d 2 6.2 7 2 11: d 2 6.2 9 1 12: d 5 6.2 7 2 13: d 5 6.2 9 1

一些解释：如果您连接两个使用相同列名的数据表，您可以通过在列名前加上i.来引用i表的列i. . 现在，您可以比较thisTime从DT与thisTime从DT_LU 。 使用by = .EACHI您可以确保条件成立的所有组合都包含在结果数据表中。

或者，您可以通过以下方式实现相同的效果：

DT2 <- DT_LU[DT, .(airport=i.airport,
                   tid=i.t_id,
                   tTime=i.thisTime,
                   fTime=thisTime[i.thisTime < thisTime],
                   fid=f_id[i.thisTime < thisTime]),
             allow.cartesian=TRUE]

这给出了相同的结果：

> identical(DT1, DT2)
[1] TRUE

当您只想在某个边界内包含未来值时，您可以使用：

DT1 <- DT_LU[DT, 
             {
               idx = i.thisTime < thisTime & thisTime - i.thisTime < 2
               .(tid  = i.t_id,
                 tTime = i.thisTime,
                 fTime = thisTime[idx],
                 fid = f_id[idx])
               },
             by=.EACHI]

这使：

 > DT1 airport tid tTime fTime fid 1: a 1 5.1 6 1 2: a 1 5.1 6 2 3: a 4 5.1 6 1 4: a 4 5.1 6 2 5: a 3 5.1 6 1 6: a 3 5.1 6 2 7: d 2 6.2 7 2 8: d 5 6.2 7 2

当您将其与之前的结果进行比较时，您会看到现在第 3、6、9、10 和 12 行已被删除。

---

数据：

DT <- data.table(t_id = c(1,4,2,3,5),
                 airport = c("a","a","d","a","d"),
                 thisTime = c(5.1, 5.1, 6.2, 5.1, 6.2),
                 key=c("airport","thisTime"))

DT_LU <- data.table(f_id = c(rep(1,4),rep(2,3)),
                    airport = c("a","b","c","d","a","d","e"),
                    thisTime = c(6,7,8,9,6,7,8),
                    key=c("airport","thisTime"))