web-dev-qa-db-fra.com

dplyr left_join par moins de, supérieur à la condition

Cette question est quelque peu liée à des problèmes Fusionner efficacement deux blocs de données sur des critères non triviaux et Vérifier si la date est comprise entre deux dates dans r . Et celui que j'ai posté ici demandant si la fonctionnalité existe: problème GitHub

Je cherche à joindre deux dataframes en utilisant dplyr::left_join(). La condition que j'utilise pour adhérer est inférieure, supérieure à, c'est-à-dire <= Et >. dplyr::left_join() prend-il en charge cette fonctionnalité? ou les touches ne prennent-elles que l'opérateur = entre elles. C'est simple à exécuter à partir de SQL (en supposant que j'ai la trame de données dans la base de données)

Voici un MWE: j'ai deux ensembles de données une année-entreprise (fdata), tandis que la seconde est une sorte de données d'enquête qui se produit une fois tous les cinq ans. Donc, pour toutes les années dans la fdata qui se situent entre deux années d'enquête, je joins les données de l'année d'enquête correspondantes.

id <- c(1,1,1,1,
        2,2,2,2,2,2,
        3,3,3,3,3,3,
        5,5,5,5,
        8,8,8,8,
        13,13,13)

fyear <- c(1998,1999,2000,2001,1998,1999,2000,2001,2002,2003,
       1998,1999,2000,2001,2002,2003,1998,1999,2000,2001,
       1998,1999,2000,2001,1998,1999,2000)

byear <- c(1990,1995,2000,2005)
eyear <- c(1995,2000,2005,2010)
val <- c(3,1,5,6)

sdata <- tbl_df(data.frame(byear, eyear, val))

fdata <- tbl_df(data.frame(id, fyear))

test1 <- left_join(fdata, sdata, by = c("fyear" >= "byear","fyear" < "eyear"))

Je reçois

Error: cannot join on columns 'TRUE' x 'TRUE': index out of bounds

À moins que left_join Puisse gérer la condition, mais qu'il manque quelque chose dans ma syntaxe?

sqlrpostgresqlleft-joindplyr
16
rajvijay

Utilisez un filter. (Mais notez que cette réponse ne pas produit un LEFT JOIN Correct; mais le MWE donne le bon résultat avec un INNER JOIN À la place.)

Le package dplyr n'est pas satisfait si on lui demande de fusionner deux tables sans quelque chose sur lequel fusionner, donc dans ce qui suit, je crée une variable fictive dans les deux tables à cet effet, puis filtre, puis supprime dummy:

fdata %>% 
    mutate(dummy=TRUE) %>%
    left_join(sdata %>% mutate(dummy=TRUE)) %>%
    filter(fyear >= byear, fyear < eyear) %>%
    select(-dummy)

Et notez que si vous le faites dans PostgreSQL (par exemple), l'optimiseur de requête voit à travers la variable dummy comme en témoignent les deux explications de requête suivantes:

> fdata %>% 
+     mutate(dummy=TRUE) %>%
+     left_join(sdata %>% mutate(dummy=TRUE)) %>%
+     filter(fyear >= byear, fyear < eyear) %>%
+     select(-dummy) %>%
+     explain()
Joining by: "dummy"
<SQL>
SELECT "id" AS "id", "fyear" AS "fyear", "byear" AS "byear", "eyear" AS "eyear", "val" AS "val"
FROM (SELECT * FROM (SELECT "id", "fyear", TRUE AS "dummy"
FROM "fdata") AS "zzz136"

LEFT JOIN 

(SELECT "byear", "eyear", "val", TRUE AS "dummy"
FROM "sdata") AS "zzz137"

USING ("dummy")) AS "zzz138"
WHERE "fyear" >= "byear" AND "fyear" < "eyear"


<PLAN>
Nested Loop  (cost=0.00..50886.88 rows=322722 width=40)
  Join Filter: ((fdata.fyear >= sdata.byear) AND (fdata.fyear < sdata.eyear))
  ->  Seq Scan on fdata  (cost=0.00..28.50 rows=1850 width=16)
  ->  Materialize  (cost=0.00..33.55 rows=1570 width=24)
        ->  Seq Scan on sdata  (cost=0.00..25.70 rows=1570 width=24)

et le faire plus proprement avec SQL donne exactement le même résultat:

> tbl(pg, sql("
+     SELECT *
+     FROM fdata 
+     LEFT JOIN sdata 
+     ON fyear >= byear AND fyear < eyear")) %>%
+     explain()
<SQL>
SELECT "id", "fyear", "byear", "eyear", "val"
FROM (
    SELECT *
    FROM fdata 
    LEFT JOIN sdata 
    ON fyear >= byear AND fyear < eyear) AS "zzz140"


<PLAN>
Nested Loop Left Join  (cost=0.00..50886.88 rows=322722 width=40)
  Join Filter: ((fdata.fyear >= sdata.byear) AND (fdata.fyear < sdata.eyear))
  ->  Seq Scan on fdata  (cost=0.00..28.50 rows=1850 width=16)
  ->  Materialize  (cost=0.00..33.55 rows=1570 width=24)
        ->  Seq Scan on sdata  (cost=0.00..25.70 rows=1570 width=24)
14
Ian Gow

data.table ajoute des jointures non équi à partir de la v 1.9.8

library(data.table) #v>=1.9.8
setDT(sdata); setDT(fdata) # converting to data.table in place

fdata[sdata, on = .(fyear >= byear, fyear < eyear), nomatch = 0,
      .(id, x.fyear, byear, eyear, val)]
#    id x.fyear byear eyear val
# 1:  1    1998  1995  2000   1
# 2:  2    1998  1995  2000   1
# 3:  3    1998  1995  2000   1
# 4:  5    1998  1995  2000   1
# 5:  8    1998  1995  2000   1
# 6: 13    1998  1995  2000   1
# 7:  1    1999  1995  2000   1
# 8:  2    1999  1995  2000   1
# 9:  3    1999  1995  2000   1
#10:  5    1999  1995  2000   1
#11:  8    1999  1995  2000   1
#12: 13    1999  1995  2000   1
#13:  1    2000  2000  2005   5
#14:  2    2000  2000  2005   5
#15:  3    2000  2000  2005   5
#16:  5    2000  2000  2005   5
#17:  8    2000  2000  2005   5
#18: 13    2000  2000  2005   5
#19:  1    2001  2000  2005   5
#20:  2    2001  2000  2005   5
#21:  3    2001  2000  2005   5
#22:  5    2001  2000  2005   5
#23:  8    2001  2000  2005   5
#24:  2    2002  2000  2005   5
#25:  3    2002  2000  2005   5
#26:  2    2003  2000  2005   5
#27:  3    2003  2000  2005   5
#    id x.fyear byear eyear val

Vous pouvez également le faire fonctionner avec foverlaps dans 1.9.6 avec un peu plus d'effort.

17
eddi

Il semble que ce soit le type de tâche que le package fuzzyjoin adresse. Les différentes fonctions du package ressemblent et fonctionnent de manière similaire aux fonctions de jointure dplyr.

Dans ce cas, l'un des fuzzy_*_join les fonctions fonctionneront pour vous. La principale différence entre dplyr::left_join et fuzzyjoin::fuzzy_left_join est que vous donnez une liste de fonctions à utiliser dans le processus de correspondance avec le match.fun argument. Notez que l'argument by est toujours écrit de la même manière que dans left_join.

Voici un exemple. Les fonctions sur lesquelles je faisais correspondre sont >= et < pour les comparaisons fyear à byear et fyear à eyear, respectivement. le

library(fuzzyjoin)

fuzzy_left_join(fdata, sdata, 
             by = c("fyear" = "byear", "fyear" = "eyear"), 
             match_fun = list(`>=`, `<`))

Source: local data frame [27 x 5]

      id fyear byear eyear   val
   (dbl) (dbl) (dbl) (dbl) (dbl)
1      1  1998  1995  2000     1
2      1  1999  1995  2000     1
3      1  2000  2000  2005     5
4      1  2001  2000  2005     5
5      2  1998  1995  2000     1
6      2  1999  1995  2000     1
7      2  2000  2000  2005     5
8      2  2001  2000  2005     5
9      2  2002  2000  2005     5
10     2  2003  2000  2005     5
..   ...   ...   ...   ...   ...
16
aosmith

Une option consiste à joindre en ligne en tant que colonne de liste, puis de supprimer le nid de la colonne:

# evaluate each row individually
fdata %>% rowwise() %>% 
    # insert list column of single row of sdata based on conditions
    mutate(s = list(sdata %>% filter(fyear >= byear, fyear < eyear))) %>% 
    # unnest list column
    tidyr::unnest()

# Source: local data frame [27 x 5]
# 
#       id fyear byear eyear   val
#    (dbl) (dbl) (dbl) (dbl) (dbl)
# 1      1  1998  1995  2000     1
# 2      1  1999  1995  2000     1
# 3      1  2000  2000  2005     5
# 4      1  2001  2000  2005     5
# 5      2  1998  1995  2000     1
# 6      2  1999  1995  2000     1
# 7      2  2000  2000  2005     5
# 8      2  2001  2000  2005     5
# 9      2  2002  2000  2005     5
# 10     2  2003  2000  2005     5
# ..   ...   ...   ...   ...   ...
2
alistaire