Cómo unir (fusionar) marcos de datos (interior, exterior, izquierda, derecha)

StackOverflow https://stackoverflow.com/questions/1299871

Pregunta

Dados dos marcos de datos:

df1 = data.frame(CustomerId = c(1:6), Product = c(rep("Toaster", 3), rep("Radio", 3)))
df2 = data.frame(CustomerId = c(2, 4, 6), State = c(rep("Alabama", 2), rep("Ohio", 1)))

df1
#  CustomerId Product
#           1 Toaster
#           2 Toaster
#           3 Toaster
#           4   Radio
#           5   Radio
#           6   Radio

df2
#  CustomerId   State
#           2 Alabama
#           4 Alabama
#           6    Ohio

¿Cómo puedo hacer el estilo de la base de datos, es decir, estilo sql, se une?Es decir, ¿cómo consigo:

  • Un unir internamente de df1 y df2:
    Devuelve solo las filas en las que la tabla de la izquierda tiene claves coincidentes en la tabla de la derecha.
  • Un unión externa de df1 y df2:
    Devuelve todas las filas de ambas tablas, une los registros de la izquierda que tienen claves coincidentes en la tabla de la derecha.
  • A unión externa izquierda (o simplemente unión izquierda) de df1 y df2
    Devuelve todas las filas de la tabla de la izquierda y cualquier fila con claves coincidentes de la tabla de la derecha.
  • A unión exterior derecha de df1 y df2
    Devuelve todas las filas de la tabla derecha y cualquier fila con claves coincidentes de la tabla izquierda.

Crédito adicional:

¿Cómo puedo hacer una declaración de selección de estilo SQL?

¿Fue útil?

Solución

Mediante el uso de la función merge y sus parámetros opcionales:

combinación interna: merge(df1, df2) trabajará para estos ejemplos porque R se une automáticamente los fotogramas por nombres de las variables comunes, pero lo más probable es que desee especificar merge(df1, df2, by = "CustomerId") para asegurarse de que se emparejaban en sólo los campos que se desee. También puede utilizar los parámetros by.x y by.y si las variables coincidentes tienen nombres diferentes en las diferentes tramas de datos.

Combinación externa: merge(x = df1, y = df2, by = "CustomerId", all = TRUE)

externa izquierda: merge(x = df1, y = df2, by = "CustomerId", all.x = TRUE)

externa derecha: merge(x = df1, y = df2, by = "CustomerId", all.y = TRUE)

Cruz unirse a: merge(x = df1, y = df2, by = NULL)

Al igual que con la unión interna, es probable que desee pasar explícitamente "CustomerId" a R como la variable correspondiente. Creo que es casi siempre la mejor manera de establecer explícitamente los identificadores en la que desea unir; es más seguro si la entrada data.frames cambiar de forma inesperada y más fácil de leer más adelante.

Puede combinar en varias columnas, dando by un vector, por ejemplo, by = c("CustomerId", "OrderId").

Si los nombres de las columnas se fusionen en no son los mismos, se puede especificar, por ejemplo, donde by.x = "CustomerId_in_df1", by.y = "CustomerId_in_df2" CustomerId_in_df1 es el nombre de la columna en la primera trama de datos y CustomerId_in_df2 es el nombre de la columna en la segunda trama de datos. (Estos también pueden ser vectores si necesita combinar en varias columnas.)

Otros consejos

Me recomiendo echar un vistazo a de Gabor Grothendieck paquete sqldf , que le permite expresar estas operaciones en SQL. 

library(sqldf)

## inner join
df3 <- sqldf("SELECT CustomerId, Product, State 
              FROM df1
              JOIN df2 USING(CustomerID)")

## left join (substitute 'right' for right join)
df4 <- sqldf("SELECT CustomerId, Product, State 
              FROM df1
              LEFT JOIN df2 USING(CustomerID)")

Me parece la sintaxis SQL para ser más simple y más natural que su equivalente R (pero esto sólo puede reflejar mi sesgo RDBMS).

de Gabor sqldf GitHub para más información sobre uniones.

No es la data.table enfoque para una combinación interna, que es muy eficiente de la memoria y el tiempo (y necesario para algunos data.frames más grandes): 

library(data.table)

dt1 <- data.table(df1, key = "CustomerId") 
dt2 <- data.table(df2, key = "CustomerId")

joined.dt1.dt.2 <- dt1[dt2]

merge también trabaja en data.tables (ya que es similar y llama merge.data.table) 

merge(dt1, dt2)

data.table documentado en stackoverflow:
Cómo hacer una operación de combinación data.table < br> Traducción uniones SQL de claves externas a los datos R. tabla de sintaxis
fusionan para ampliar la data.frames R
Cómo hacer una izquierda básica combinación externa con data.table en R?

Sin embargo, otra opción es la función join encontrado en el href="http://cran.r-project.org/web/packages/plyr/index.html" rel="noreferrer"> paquete 

library(plyr)

join(df1, df2,
     type = "inner")

#   CustomerId Product   State
# 1          2 Toaster Alabama
# 2          4   Radio Alabama
# 3          6   Radio    Ohio

Las opciones para type:. inner, left, right, full

De ?join:. A diferencia de merge, [join] conserva el orden de x no importa lo que se unen se utiliza el tipo

Puede hacer une así el uso de dplyr paquete . 

library(dplyr)

#make sure that CustomerId cols are both type numeric
#they ARE not using the provided code in question and dplyr will complain
df1$CustomerId <- as.numeric(df1$CustomerId)
df2$CustomerId <- as.numeric(df2$CustomerId)

Mutating une: agregar columnas a DF1 usando partidos en gl2 

#inner
inner_join(df1, df2)

#left outer
left_join(df1, df2)

#right outer
right_join(df1, df2)

#alternate right outer
left_join(df2, df1)

#full join
full_join(df1, df2)

Filtrado une: a filtrar las filas de DF1, no modifique las columnas 

semi_join(df1, df2) #keep only observations in df1 that match in df2.
anti_join(df1, df2) #drops all observations in df1 that match in df2.

Hay algunos buenos ejemplos de esta manera sobre la R Wiki . Voy a robar un par aquí:

Método de fusión

Dado que las llaves se nombran el mismo camino corto para hacer una unión interna se merge (): 

merge(df1,df2)

un interior lleno unen (todos los registros de ambas tablas) se pueden crear con el "todo" palabra clave: 

merge(df1,df2, all=TRUE)

una combinación externa izquierda de DF1 y DF2: 

merge(df1,df2, all.x=TRUE)

se unen a una combinación externa derecha de DF1 y DF2: 

merge(df1,df2, all.y=TRUE)

se puede voltear 'em, slap' em y frotar 'em hacia abajo para obtener las otras dos combinaciones externas que preguntaste:)

Subíndice Método

A la izquierda combinación externa con DF1 a la izquierda usando un método subíndice sería: 

df1[,"State"]<-df2[df1[ ,"Product"], "State"]

La otra combinación de combinaciones externas puede ser creado por el mungling externa izquierda ejemplo subíndice. (Sí, ya sé que es el equivalente a decir "Lo dejo como ejercicio para el lector ...")

Nuevo en 2014:

Sobre todo si también está interesado en la manipulación de datos en general (incluyendo clasificación, filtrado, de subconjuntos, resumir, etc.), debería echar un vistazo a dplyr, que viene con una variedad de funciones todas ellas diseñadas para facilitar su trabajo específicamente de tramas de datos y otros tipos de bases de datos. Incluso ofrece toda una interfaz SQL elaborado, e incluso una función para convertir (la mayoría) de código SQL directamente en R.

Las cuatro funciones relacionadas con la unión-en el paquete dplyr son (a la cita):

  • inner_join(x, y, by = NULL, copy = FALSE, ...): devolver todas las filas de x donde hay valores en Y, y todas las columnas de X e Y a juego
  • left_join(x, y, by = NULL, copy = FALSE, ...): devolver todas las filas de x, y todas las columnas de X e Y
  • semi_join(x, y, by = NULL, copy = FALSE, ...): volver todas las filas de x en los que hay valores para los productos en Y, manteniendo sólo las columnas de x.
  • anti_join(x, y, by = NULL, copy = FALSE, ...): devolver todas las filas de x donde no están haciendo juego valores en Y, manteniendo sólo las columnas de x

Es todo aquí con gran detalle.

Selección de columnas se pueden hacer por select(df,"column"). Si eso no es SQL-ish suficiente para ti, entonces no hay la función sql(), en el que puede introducir el código SQL tal y como son, y que va a hacer la operación que ha especificado al igual que estuviera escribiendo en I a lo largo (para más información, por favor consulte la dplyr / bases de datos viñeta ). Por ejemplo, si se aplica correctamente, sql("SELECT * FROM hflights") seleccionará todas las columnas de la "hflights" mesa dplyr (un "TBL").

Actualización sobre métodos data.table para unirse a los conjuntos de datos. Vea a continuación ejemplos para cada tipo de unión. Hay dos métodos, uno de [.data.table cuando pasa a segundo data.table como primer argumento al subconjunto, otra forma es utilizar la función merge que despacha a ayunar método data.table. 

df1 = data.frame(CustomerId = c(1:6), Product = c(rep("Toaster", 3), rep("Radio", 3)))
df2 = data.frame(CustomerId = c(2L, 4L, 7L), State = c(rep("Alabama", 2), rep("Ohio", 1))) # one value changed to show full outer join

library(data.table)

dt1 = as.data.table(df1)
dt2 = as.data.table(df2)
setkey(dt1, CustomerId)
setkey(dt2, CustomerId)
# right outer join keyed data.tables
dt1[dt2]

setkey(dt1, NULL)
setkey(dt2, NULL)
# right outer join unkeyed data.tables - use `on` argument
dt1[dt2, on = "CustomerId"]

# left outer join - swap dt1 with dt2
dt2[dt1, on = "CustomerId"]

# inner join - use `nomatch` argument
dt1[dt2, nomatch=NULL, on = "CustomerId"]

# anti join - use `!` operator
dt1[!dt2, on = "CustomerId"]

# inner join - using merge method
merge(dt1, dt2, by = "CustomerId")

# full outer join
merge(dt1, dt2, by = "CustomerId", all = TRUE)

# see ?merge.data.table arguments for other cases

A continuación base de las pruebas de referencia R, sqldf, dplyr y data.table.
Las pruebas de referencia / conjuntos de datos no indexados sin codificar. Benchmark se realiza en 50M-1 filas conjuntos de datos, hay valores comunes de unirse a la columna de modo que cada escenario (interior, izquierda, derecha, completo) puede ser probado y unir 2 50M-todavía no es trivial para llevar a cabo. Es el tipo de unirse a los que el estrés también se unen a los algoritmos. Tiempos son como de sqldf:0.4.11, dplyr:0.7.8, data.table:1.12.0. 

# inner
Unit: seconds
   expr       min        lq      mean    median        uq       max neval
   base 111.66266 111.66266 111.66266 111.66266 111.66266 111.66266     1
  sqldf 624.88388 624.88388 624.88388 624.88388 624.88388 624.88388     1
  dplyr  51.91233  51.91233  51.91233  51.91233  51.91233  51.91233     1
     DT  10.40552  10.40552  10.40552  10.40552  10.40552  10.40552     1
# left
Unit: seconds
   expr        min         lq       mean     median         uq        max 
   base 142.782030 142.782030 142.782030 142.782030 142.782030 142.782030     
  sqldf 613.917109 613.917109 613.917109 613.917109 613.917109 613.917109     
  dplyr  49.711912  49.711912  49.711912  49.711912  49.711912  49.711912     
     DT   9.674348   9.674348   9.674348   9.674348   9.674348   9.674348       
# right
Unit: seconds
   expr        min         lq       mean     median         uq        max
   base 122.366301 122.366301 122.366301 122.366301 122.366301 122.366301     
  sqldf 611.119157 611.119157 611.119157 611.119157 611.119157 611.119157     
  dplyr  50.384841  50.384841  50.384841  50.384841  50.384841  50.384841     
     DT   9.899145   9.899145   9.899145   9.899145   9.899145   9.899145     
# full
Unit: seconds
  expr       min        lq      mean    median        uq       max neval
  base 141.79464 141.79464 141.79464 141.79464 141.79464 141.79464     1
 dplyr  94.66436  94.66436  94.66436  94.66436  94.66436  94.66436     1
    DT  21.62573  21.62573  21.62573  21.62573  21.62573  21.62573     1

Tenga en cuenta que hay otros tipos de uniones se pueden realizar utilizando data.table:
  - Actualización en unirse a - si quieres para buscar los valores de otra tabla a la tabla principal
  - agregada en unirse a - si desea agregar en la tecla se está uniendo a que no tiene que materializarse todos se unen resultados
  - superposición de unirse a - si desea combinar por rangos
  - rodando unirse a - si desea fusionar para poder coincidir con los valores de precedente / siguiente filas haciéndolas rodar hacia delante o atrás
  - no equi unirse - si su condición de unión no es igual

El código para reproducir: 

library(microbenchmark)
library(sqldf)
library(dplyr)
library(data.table)
sapply(c("sqldf","dplyr","data.table"), packageVersion, simplify=FALSE)

n = 5e7
set.seed(108)
df1 = data.frame(x=sample(n,n-1L), y1=rnorm(n-1L))
df2 = data.frame(x=sample(n,n-1L), y2=rnorm(n-1L))
dt1 = as.data.table(df1)
dt2 = as.data.table(df2)

mb = list()
# inner join
microbenchmark(times = 1L,
               base = merge(df1, df2, by = "x"),
               sqldf = sqldf("SELECT * FROM df1 INNER JOIN df2 ON df1.x = df2.x"),
               dplyr = inner_join(df1, df2, by = "x"),
               DT = dt1[dt2, nomatch=NULL, on = "x"]) -> mb$inner

# left outer join
microbenchmark(times = 1L,
               base = merge(df1, df2, by = "x", all.x = TRUE),
               sqldf = sqldf("SELECT * FROM df1 LEFT OUTER JOIN df2 ON df1.x = df2.x"),
               dplyr = left_join(df1, df2, by = c("x"="x")),
               DT = dt2[dt1, on = "x"]) -> mb$left

# right outer join
microbenchmark(times = 1L,
               base = merge(df1, df2, by = "x", all.y = TRUE),
               sqldf = sqldf("SELECT * FROM df2 LEFT OUTER JOIN df1 ON df2.x = df1.x"),
               dplyr = right_join(df1, df2, by = "x"),
               DT = dt1[dt2, on = "x"]) -> mb$right

# full outer join
microbenchmark(times = 1L,
               base = merge(df1, df2, by = "x", all = TRUE),
               dplyr = full_join(df1, df2, by = "x"),
               DT = merge(dt1, dt2, by = "x", all = TRUE)) -> mb$full

lapply(mb, print) -> nul

dplyr desde 0,4 implementados todos los une incluyendo outer_join, pero valió la pena señalar que para las primeras versiones anteriores a la 0.4 que utiliza no ofrecer outer_join, y como resultado se produjo una gran cantidad de muy mala solución hacky código de usuario flotando alrededor durante bastante tiempo después (aún se pueden encontrar tal código en SO, Kaggle respuestas, github de la época. por lo tanto esta respuesta todavía sirve a un propósito útil.)

Relevantes :

v0.5 (6/2016)

  • Manipulación para el tipo POSIXct, zonas horarias, duplicados, diferentes niveles de los factores. Mejores errores y advertencias.
  • Nueva argumento sufijo sufijo para controlar lo que duplican los nombres de variables reciben (# 1296)

v0.4.0 (1/2015)

v0.3 (10/2014)

  • Ahora se puede left_join por diferentes variables de cada tabla: DF1%>% left_join (DF2, c ( "var1" = "var2"))

v0.2 (5/2014)

  • * _ join () ya no reordena los nombres de columna (# 324)

v0.1.3 (4/2014)

Soluciones provisionales por los comentarios de Hadley en esta cuestión:

  • RIGHT_JOIN (x, y) es la misma que left_join (y, x) en términos de las filas, sólo las columnas serán diferentes órdenes. Fácil de trabajar alrededor con select (new_column_order)
  • outer_join es básicamente unión (left_join (x, y), RIGHT_JOIN (x, y)) -. Es decir, conservar todas las filas en ambas tramas de datos

En la unión de dos tramas de datos con 1 millón de filas ~ cada uno, uno con 2 columnas y el otro con ~ 20, he encontrado sorprendentemente merge(..., all.x = TRUE, all.y = TRUE) ser más rápido que dplyr::full_join(). Esta es la versión 0.4 dplyr

Combinar tarda unos 17 segundos, full_join tarda unos 65 segundos.

Algunos elementos de embargo, ya que por lo general DEFAULT para dplyr para tareas de manipulación.

Para el caso de una unión izquierda con un 0..*:0..1 cardinalidad o una unión derecha con una 0..1:0..* cardinalidad es posible asignar in situ las columnas unilaterales del carpintero (el 0..1 mesa) directamente sobre el miembro (el 0..* table), y así evitar la creación de una tabla de datos completamente nueva.Esto requiere hacer coincidir las columnas clave del miembro que se une al miembro que se une e indexar y ordenar las filas del miembro que se une en consecuencia para la tarea.

Si la clave es una sola columna, entonces podemos usar una sola llamada para match() para hacer el emparejamiento.Este es el caso que cubriré en esta respuesta.

Aquí hay un ejemplo basado en el OP, excepto que agregué una fila adicional a df2 con una identificación de 7 para probar el caso de una clave que no coincide en el ensamblador.Esto es efectivamente df1 unirse a la izquierda df2:

df1 <- data.frame(CustomerId=1:6,Product=c(rep('Toaster',3L),rep('Radio',3L)));
df2 <- data.frame(CustomerId=c(2L,4L,6L,7L),State=c(rep('Alabama',2L),'Ohio','Texas'));
df1[names(df2)[-1L]] <- df2[match(df1[,1L],df2[,1L]),-1L];
df1;
##   CustomerId Product   State
## 1          1 Toaster    <NA>
## 2          2 Toaster Alabama
## 3          3 Toaster    <NA>
## 4          4   Radio Alabama
## 5          5   Radio    <NA>
## 6          6   Radio    Ohio

En lo anterior codifiqué la suposición de que la columna clave es la primera columna de ambas tablas de entrada.Yo diría que, en general, esta no es una suposición irrazonable, ya que, si tiene un marco de datos con una columna clave, sería extraño si no se hubiera configurado como la primera columna del marco de datos de El principio.Y siempre puedes reordenar las columnas para que así sea.Una consecuencia ventajosa de esta suposición es que el nombre de la columna clave no tiene que estar codificado, aunque supongo que simplemente se trata de reemplazar una suposición por otra.La concisión es otra ventaja de la indexación de números enteros, así como la velocidad.En los puntos de referencia a continuación, cambiaré la implementación para usar la indexación de nombres de cadenas para que coincida con las implementaciones de la competencia.

Creo que esta es una solución particularmente apropiada si tiene varias tablas que desea unir a la izquierda en una sola tabla grande.Reconstruir repetidamente toda la tabla para cada combinación sería innecesario e ineficiente.

Por otro lado, si necesita que el miembro permanezca inalterado durante esta operación por cualquier motivo, entonces esta solución no se puede utilizar, ya que modifica al miembro directamente.Aunque en ese caso podría simplemente hacer una copia y realizar las asignaciones in situ en la copia.

Como nota al margen, analicé brevemente posibles soluciones coincidentes para claves de varias columnas.Desafortunadamente, las únicas soluciones coincidentes que encontré fueron:

  • Concatenaciones ineficientes.p.ej. match(interaction(df1$a,df1$b),interaction(df2$a,df2$b)), o la misma idea con paste().
  • conjunciones cartesianas ineficientes, p.e. outer(df1$a,df2$a,`==`) & outer(df1$b,df2$b,`==`).
  • base R merge() y funciones de combinación basadas en paquetes equivalentes, que siempre asignan una nueva tabla para devolver el resultado combinado y, por lo tanto, no son adecuadas para una solución basada en asignaciones in situ.

Por ejemplo, ver Hacer coincidir varias columnas en diferentes marcos de datos y obtener otra columna como resultado, unir dos columnas con otras dos columnas, Coincidencia en varias columnas, y el engaño de esta pregunta donde originalmente se me ocurrió la solución local, Combine dos marcos de datos con diferente número de filas en R.

Evaluación comparativa

Decidí hacer mi propia evaluación comparativa para ver cómo se compara el enfoque de asignación in situ con las otras soluciones que se han ofrecido en esta pregunta.

Código de prueba:

library(microbenchmark);
library(data.table);
library(sqldf);
library(plyr);
library(dplyr);

solSpecs <- list(
    merge=list(testFuncs=list(
        inner=function(df1,df2,key) merge(df1,df2,key),
        left =function(df1,df2,key) merge(df1,df2,key,all.x=T),
        right=function(df1,df2,key) merge(df1,df2,key,all.y=T),
        full =function(df1,df2,key) merge(df1,df2,key,all=T)
    )),
    data.table.unkeyed=list(argSpec='data.table.unkeyed',testFuncs=list(
        inner=function(dt1,dt2,key) dt1[dt2,on=key,nomatch=0L,allow.cartesian=T],
        left =function(dt1,dt2,key) dt2[dt1,on=key,allow.cartesian=T],
        right=function(dt1,dt2,key) dt1[dt2,on=key,allow.cartesian=T],
        full =function(dt1,dt2,key) merge(dt1,dt2,key,all=T,allow.cartesian=T) ## calls merge.data.table()
    )),
    data.table.keyed=list(argSpec='data.table.keyed',testFuncs=list(
        inner=function(dt1,dt2) dt1[dt2,nomatch=0L,allow.cartesian=T],
        left =function(dt1,dt2) dt2[dt1,allow.cartesian=T],
        right=function(dt1,dt2) dt1[dt2,allow.cartesian=T],
        full =function(dt1,dt2) merge(dt1,dt2,all=T,allow.cartesian=T) ## calls merge.data.table()
    )),
    sqldf.unindexed=list(testFuncs=list( ## note: must pass connection=NULL to avoid running against the live DB connection, which would result in collisions with the residual tables from the last query upload
        inner=function(df1,df2,key) sqldf(paste0('select * from df1 inner join df2 using(',paste(collapse=',',key),')'),connection=NULL),
        left =function(df1,df2,key) sqldf(paste0('select * from df1 left join df2 using(',paste(collapse=',',key),')'),connection=NULL),
        right=function(df1,df2,key) sqldf(paste0('select * from df2 left join df1 using(',paste(collapse=',',key),')'),connection=NULL) ## can't do right join proper, not yet supported; inverted left join is equivalent
        ##full =function(df1,df2,key) sqldf(paste0('select * from df1 full join df2 using(',paste(collapse=',',key),')'),connection=NULL) ## can't do full join proper, not yet supported; possible to hack it with a union of left joins, but too unreasonable to include in testing
    )),
    sqldf.indexed=list(testFuncs=list( ## important: requires an active DB connection with preindexed main.df1 and main.df2 ready to go; arguments are actually ignored
        inner=function(df1,df2,key) sqldf(paste0('select * from main.df1 inner join main.df2 using(',paste(collapse=',',key),')')),
        left =function(df1,df2,key) sqldf(paste0('select * from main.df1 left join main.df2 using(',paste(collapse=',',key),')')),
        right=function(df1,df2,key) sqldf(paste0('select * from main.df2 left join main.df1 using(',paste(collapse=',',key),')')) ## can't do right join proper, not yet supported; inverted left join is equivalent
        ##full =function(df1,df2,key) sqldf(paste0('select * from main.df1 full join main.df2 using(',paste(collapse=',',key),')')) ## can't do full join proper, not yet supported; possible to hack it with a union of left joins, but too unreasonable to include in testing
    )),
    plyr=list(testFuncs=list(
        inner=function(df1,df2,key) join(df1,df2,key,'inner'),
        left =function(df1,df2,key) join(df1,df2,key,'left'),
        right=function(df1,df2,key) join(df1,df2,key,'right'),
        full =function(df1,df2,key) join(df1,df2,key,'full')
    )),
    dplyr=list(testFuncs=list(
        inner=function(df1,df2,key) inner_join(df1,df2,key),
        left =function(df1,df2,key) left_join(df1,df2,key),
        right=function(df1,df2,key) right_join(df1,df2,key),
        full =function(df1,df2,key) full_join(df1,df2,key)
    )),
    in.place=list(testFuncs=list(
        left =function(df1,df2,key) { cns <- setdiff(names(df2),key); df1[cns] <- df2[match(df1[,key],df2[,key]),cns]; df1; },
        right=function(df1,df2,key) { cns <- setdiff(names(df1),key); df2[cns] <- df1[match(df2[,key],df1[,key]),cns]; df2; }
    ))
);

getSolTypes <- function() names(solSpecs);
getJoinTypes <- function() unique(unlist(lapply(solSpecs,function(x) names(x$testFuncs))));
getArgSpec <- function(argSpecs,key=NULL) if (is.null(key)) argSpecs$default else argSpecs[[key]];

initSqldf <- function() {
    sqldf(); ## creates sqlite connection on first run, cleans up and closes existing connection otherwise
    if (exists('sqldfInitFlag',envir=globalenv(),inherits=F) && sqldfInitFlag) { ## false only on first run
        sqldf(); ## creates a new connection
    } else {
        assign('sqldfInitFlag',T,envir=globalenv()); ## set to true for the one and only time
    }; ## end if
    invisible();
}; ## end initSqldf()

setUpBenchmarkCall <- function(argSpecs,joinType,solTypes=getSolTypes(),env=parent.frame()) {
    ## builds and returns a list of expressions suitable for passing to the list argument of microbenchmark(), and assigns variables to resolve symbol references in those expressions
    callExpressions <- list();
    nms <- character();
    for (solType in solTypes) {
        testFunc <- solSpecs[[solType]]$testFuncs[[joinType]];
        if (is.null(testFunc)) next; ## this join type is not defined for this solution type
        testFuncName <- paste0('tf.',solType);
        assign(testFuncName,testFunc,envir=env);
        argSpecKey <- solSpecs[[solType]]$argSpec;
        argSpec <- getArgSpec(argSpecs,argSpecKey);
        argList <- setNames(nm=names(argSpec$args),vector('list',length(argSpec$args)));
        for (i in seq_along(argSpec$args)) {
            argName <- paste0('tfa.',argSpecKey,i);
            assign(argName,argSpec$args[[i]],envir=env);
            argList[[i]] <- if (i%in%argSpec$copySpec) call('copy',as.symbol(argName)) else as.symbol(argName);
        }; ## end for
        callExpressions[[length(callExpressions)+1L]] <- do.call(call,c(list(testFuncName),argList),quote=T);
        nms[length(nms)+1L] <- solType;
    }; ## end for
    names(callExpressions) <- nms;
    callExpressions;
}; ## end setUpBenchmarkCall()

harmonize <- function(res) {
    res <- as.data.frame(res); ## coerce to data.frame
    for (ci in which(sapply(res,is.factor))) res[[ci]] <- as.character(res[[ci]]); ## coerce factor columns to character
    for (ci in which(sapply(res,is.logical))) res[[ci]] <- as.integer(res[[ci]]); ## coerce logical columns to integer (works around sqldf quirk of munging logicals to integers)
    ##for (ci in which(sapply(res,inherits,'POSIXct'))) res[[ci]] <- as.double(res[[ci]]); ## coerce POSIXct columns to double (works around sqldf quirk of losing POSIXct class) ----- POSIXct doesn't work at all in sqldf.indexed
    res <- res[order(names(res))]; ## order columns
    res <- res[do.call(order,res),]; ## order rows
    res;
}; ## end harmonize()

checkIdentical <- function(argSpecs,solTypes=getSolTypes()) {
    for (joinType in getJoinTypes()) {
        callExpressions <- setUpBenchmarkCall(argSpecs,joinType,solTypes);
        if (length(callExpressions)<2L) next;
        ex <- harmonize(eval(callExpressions[[1L]]));
        for (i in seq(2L,len=length(callExpressions)-1L)) {
            y <- harmonize(eval(callExpressions[[i]]));
            if (!isTRUE(all.equal(ex,y,check.attributes=F))) {
                ex <<- ex;
                y <<- y;
                solType <- names(callExpressions)[i];
                stop(paste0('non-identical: ',solType,' ',joinType,'.'));
            }; ## end if
        }; ## end for
    }; ## end for
    invisible();
}; ## end checkIdentical()

testJoinType <- function(argSpecs,joinType,solTypes=getSolTypes(),metric=NULL,times=100L) {
    callExpressions <- setUpBenchmarkCall(argSpecs,joinType,solTypes);
    bm <- microbenchmark(list=callExpressions,times=times);
    if (is.null(metric)) return(bm);
    bm <- summary(bm);
    res <- setNames(nm=names(callExpressions),bm[[metric]]);
    attr(res,'unit') <- attr(bm,'unit');
    res;
}; ## end testJoinType()

testAllJoinTypes <- function(argSpecs,solTypes=getSolTypes(),metric=NULL,times=100L) {
    joinTypes <- getJoinTypes();
    resList <- setNames(nm=joinTypes,lapply(joinTypes,function(joinType) testJoinType(argSpecs,joinType,solTypes,metric,times)));
    if (is.null(metric)) return(resList);
    units <- unname(unlist(lapply(resList,attr,'unit')));
    res <- do.call(data.frame,c(list(join=joinTypes),setNames(nm=solTypes,rep(list(rep(NA_real_,length(joinTypes))),length(solTypes))),list(unit=units,stringsAsFactors=F)));
    for (i in seq_along(resList)) res[i,match(names(resList[[i]]),names(res))] <- resList[[i]];
    res;
}; ## end testAllJoinTypes()

testGrid <- function(makeArgSpecsFunc,sizes,overlaps,solTypes=getSolTypes(),joinTypes=getJoinTypes(),metric='median',times=100L) {

    res <- expand.grid(size=sizes,overlap=overlaps,joinType=joinTypes,stringsAsFactors=F);
    res[solTypes] <- NA_real_;
    res$unit <- NA_character_;
    for (ri in seq_len(nrow(res))) {

        size <- res$size[ri];
        overlap <- res$overlap[ri];
        joinType <- res$joinType[ri];

        argSpecs <- makeArgSpecsFunc(size,overlap);

        checkIdentical(argSpecs,solTypes);

        cur <- testJoinType(argSpecs,joinType,solTypes,metric,times);
        res[ri,match(names(cur),names(res))] <- cur;
        res$unit[ri] <- attr(cur,'unit');

    }; ## end for

    res;

}; ## end testGrid()

Aquí hay una prueba comparativa del ejemplo basado en el OP que demostré anteriormente:

## OP's example, supplemented with a non-matching row in df2
argSpecs <- list(
    default=list(copySpec=1:2,args=list(
        df1 <- data.frame(CustomerId=1:6,Product=c(rep('Toaster',3L),rep('Radio',3L))),
        df2 <- data.frame(CustomerId=c(2L,4L,6L,7L),State=c(rep('Alabama',2L),'Ohio','Texas')),
        'CustomerId'
    )),
    data.table.unkeyed=list(copySpec=1:2,args=list(
        as.data.table(df1),
        as.data.table(df2),
        'CustomerId'
    )),
    data.table.keyed=list(copySpec=1:2,args=list(
        setkey(as.data.table(df1),CustomerId),
        setkey(as.data.table(df2),CustomerId)
    ))
);
## prepare sqldf
initSqldf();
sqldf('create index df1_key on df1(CustomerId);'); ## upload and create an sqlite index on df1
sqldf('create index df2_key on df2(CustomerId);'); ## upload and create an sqlite index on df2

checkIdentical(argSpecs);

testAllJoinTypes(argSpecs,metric='median');
##    join    merge data.table.unkeyed data.table.keyed sqldf.unindexed sqldf.indexed      plyr    dplyr in.place         unit
## 1 inner  644.259           861.9345          923.516        9157.752      1580.390  959.2250 270.9190       NA microseconds
## 2  left  713.539           888.0205          910.045        8820.334      1529.714  968.4195 270.9185 224.3045 microseconds
## 3 right 1221.804           909.1900          923.944        8930.668      1533.135 1063.7860 269.8495 218.1035 microseconds
## 4  full 1302.203          3107.5380         3184.729              NA            NA 1593.6475 270.7055       NA microseconds

Aquí comparo datos de entrada aleatorios, probando diferentes escalas y diferentes patrones de superposición de claves entre las dos tablas de entrada.Este punto de referencia todavía está restringido al caso de una clave entera de una sola columna.Además, para garantizar que la solución in situ funcione para uniones izquierda y derecha de las mismas tablas, todos los datos de prueba aleatorios utilizan 0..1:0..1 cardinalidad.Esto se implementa muestreando sin reemplazo la columna clave del primer marco de datos al generar la columna clave del segundo marco de datos.

makeArgSpecs.singleIntegerKey.optionalOneToOne <- function(size,overlap) {

    com <- as.integer(size*overlap);

    argSpecs <- list(
        default=list(copySpec=1:2,args=list(
            df1 <- data.frame(id=sample(size),y1=rnorm(size),y2=rnorm(size)),
            df2 <- data.frame(id=sample(c(if (com>0L) sample(df1$id,com) else integer(),seq(size+1L,len=size-com))),y3=rnorm(size),y4=rnorm(size)),
            'id'
        )),
        data.table.unkeyed=list(copySpec=1:2,args=list(
            as.data.table(df1),
            as.data.table(df2),
            'id'
        )),
        data.table.keyed=list(copySpec=1:2,args=list(
            setkey(as.data.table(df1),id),
            setkey(as.data.table(df2),id)
        ))
    );
    ## prepare sqldf
    initSqldf();
    sqldf('create index df1_key on df1(id);'); ## upload and create an sqlite index on df1
    sqldf('create index df2_key on df2(id);'); ## upload and create an sqlite index on df2

    argSpecs;

}; ## end makeArgSpecs.singleIntegerKey.optionalOneToOne()

## cross of various input sizes and key overlaps
sizes <- c(1e1L,1e3L,1e6L);
overlaps <- c(0.99,0.5,0.01);
system.time({ res <- testGrid(makeArgSpecs.singleIntegerKey.optionalOneToOne,sizes,overlaps); });
##     user   system  elapsed
## 22024.65 12308.63 34493.19

Escribí un código para crear gráficos log-log de los resultados anteriores.Generé un gráfico separado para cada porcentaje de superposición.Está un poco desordenado, pero me gusta tener todos los tipos de soluciones y tipos de unión representados en el mismo gráfico.

Utilicé interpolación spline para mostrar una curva suave para cada combinación de solución/tipo de unión, dibujada con símbolos pch individuales.El tipo de unión se captura mediante el símbolo pch, utilizando un punto para el interior, corchetes angulares izquierdo y derecho para izquierda y derecha, y un diamante para completo.El tipo de solución se captura por el color como se muestra en la leyenda.

plotRes <- function(res,titleFunc,useFloor=F) {
    solTypes <- setdiff(names(res),c('size','overlap','joinType','unit')); ## derive from res
    normMult <- c(microseconds=1e-3,milliseconds=1); ## normalize to milliseconds
    joinTypes <- getJoinTypes();
    cols <- c(merge='purple',data.table.unkeyed='blue',data.table.keyed='#00DDDD',sqldf.unindexed='brown',sqldf.indexed='orange',plyr='red',dplyr='#00BB00',in.place='magenta');
    pchs <- list(inner=20L,left='<',right='>',full=23L);
    cexs <- c(inner=0.7,left=1,right=1,full=0.7);
    NP <- 60L;
    ord <- order(decreasing=T,colMeans(res[res$size==max(res$size),solTypes],na.rm=T));
    ymajors <- data.frame(y=c(1,1e3),label=c('1ms','1s'),stringsAsFactors=F);
    for (overlap in unique(res$overlap)) {
        x1 <- res[res$overlap==overlap,];
        x1[solTypes] <- x1[solTypes]*normMult[x1$unit]; x1$unit <- NULL;
        xlim <- c(1e1,max(x1$size));
        xticks <- 10^seq(log10(xlim[1L]),log10(xlim[2L]));
        ylim <- c(1e-1,10^((if (useFloor) floor else ceiling)(log10(max(x1[solTypes],na.rm=T))))); ## use floor() to zoom in a little more, only sqldf.unindexed will break above, but xpd=NA will keep it visible
        yticks <- 10^seq(log10(ylim[1L]),log10(ylim[2L]));
        yticks.minor <- rep(yticks[-length(yticks)],each=9L)*1:9;
        plot(NA,xlim=xlim,ylim=ylim,xaxs='i',yaxs='i',axes=F,xlab='size (rows)',ylab='time (ms)',log='xy');
        abline(v=xticks,col='lightgrey');
        abline(h=yticks.minor,col='lightgrey',lty=3L);
        abline(h=yticks,col='lightgrey');
        axis(1L,xticks,parse(text=sprintf('10^%d',as.integer(log10(xticks)))));
        axis(2L,yticks,parse(text=sprintf('10^%d',as.integer(log10(yticks)))),las=1L);
        axis(4L,ymajors$y,ymajors$label,las=1L,tick=F,cex.axis=0.7,hadj=0.5);
        for (joinType in rev(joinTypes)) { ## reverse to draw full first, since it's larger and would be more obtrusive if drawn last
            x2 <- x1[x1$joinType==joinType,];
            for (solType in solTypes) {
                if (any(!is.na(x2[[solType]]))) {
                    xy <- spline(x2$size,x2[[solType]],xout=10^(seq(log10(x2$size[1L]),log10(x2$size[nrow(x2)]),len=NP)));
                    points(xy$x,xy$y,pch=pchs[[joinType]],col=cols[solType],cex=cexs[joinType],xpd=NA);
                }; ## end if
            }; ## end for
        }; ## end for
        ## custom legend
        ## due to logarithmic skew, must do all distance calcs in inches, and convert to user coords afterward
        ## the bottom-left corner of the legend will be defined in normalized figure coords, although we can convert to inches immediately
        leg.cex <- 0.7;
        leg.x.in <- grconvertX(0.275,'nfc','in');
        leg.y.in <- grconvertY(0.6,'nfc','in');
        leg.x.user <- grconvertX(leg.x.in,'in');
        leg.y.user <- grconvertY(leg.y.in,'in');
        leg.outpad.w.in <- 0.1;
        leg.outpad.h.in <- 0.1;
        leg.midpad.w.in <- 0.1;
        leg.midpad.h.in <- 0.1;
        leg.sol.w.in <- max(strwidth(solTypes,'in',leg.cex));
        leg.sol.h.in <- max(strheight(solTypes,'in',leg.cex))*1.5; ## multiplication factor for greater line height
        leg.join.w.in <- max(strheight(joinTypes,'in',leg.cex))*1.5; ## ditto
        leg.join.h.in <- max(strwidth(joinTypes,'in',leg.cex));
        leg.main.w.in <- leg.join.w.in*length(joinTypes);
        leg.main.h.in <- leg.sol.h.in*length(solTypes);
        leg.x2.user <- grconvertX(leg.x.in+leg.outpad.w.in*2+leg.main.w.in+leg.midpad.w.in+leg.sol.w.in,'in');
        leg.y2.user <- grconvertY(leg.y.in+leg.outpad.h.in*2+leg.main.h.in+leg.midpad.h.in+leg.join.h.in,'in');
        leg.cols.x.user <- grconvertX(leg.x.in+leg.outpad.w.in+leg.join.w.in*(0.5+seq(0L,length(joinTypes)-1L)),'in');
        leg.lines.y.user <- grconvertY(leg.y.in+leg.outpad.h.in+leg.main.h.in-leg.sol.h.in*(0.5+seq(0L,length(solTypes)-1L)),'in');
        leg.sol.x.user <- grconvertX(leg.x.in+leg.outpad.w.in+leg.main.w.in+leg.midpad.w.in,'in');
        leg.join.y.user <- grconvertY(leg.y.in+leg.outpad.h.in+leg.main.h.in+leg.midpad.h.in,'in');
        rect(leg.x.user,leg.y.user,leg.x2.user,leg.y2.user,col='white');
        text(leg.sol.x.user,leg.lines.y.user,solTypes[ord],cex=leg.cex,pos=4L,offset=0);
        text(leg.cols.x.user,leg.join.y.user,joinTypes,cex=leg.cex,pos=4L,offset=0,srt=90); ## srt rotation applies *after* pos/offset positioning
        for (i in seq_along(joinTypes)) {
            joinType <- joinTypes[i];
            points(rep(leg.cols.x.user[i],length(solTypes)),ifelse(colSums(!is.na(x1[x1$joinType==joinType,solTypes[ord]]))==0L,NA,leg.lines.y.user),pch=pchs[[joinType]],col=cols[solTypes[ord]]);
        }; ## end for
        title(titleFunc(overlap));
        readline(sprintf('overlap %.02f',overlap));
    }; ## end for
}; ## end plotRes()

titleFunc <- function(overlap) sprintf('R merge solutions: single-column integer key, 0..1:0..1 cardinality, %d%% overlap',as.integer(overlap*100));
plotRes(res,titleFunc,T);

R-merge-benchmark-single-column-integer-key-optional-one-to-one-99

R-merge-benchmark-single-column-integer-key-optional-one-to-one-50

R-merge-benchmark-single-column-integer-key-optional-one-to-one-1

Aquí hay un segundo punto de referencia a gran escala que es más exigente con respecto al número y tipos de columnas clave, así como a la cardinalidad.Para este punto de referencia utilizo tres columnas clave:un carácter, un número entero y uno lógico, sin restricciones de cardinalidad (es decir, 0..*:0..*).(En general, no es recomendable definir columnas clave con valores dobles o complejos debido a complicaciones de comparación de punto flotante, y básicamente nadie usa el tipo sin formato, mucho menos para columnas clave, por lo que no he incluido esos tipos en la clave columnas.Además, a modo de información, inicialmente intenté usar cuatro columnas de clave incluyendo una columna de clave POSIXct, pero el tipo POSIXct no funcionaba bien con el sqldf.indexed solución por alguna razón, posiblemente debido a anomalías de comparación de punto flotante, así que la eliminé).

makeArgSpecs.assortedKey.optionalManyToMany <- function(size,overlap,uniquePct=75) {

    ## number of unique keys in df1
    u1Size <- as.integer(size*uniquePct/100);

    ## (roughly) divide u1Size into bases, so we can use expand.grid() to produce the required number of unique key values with repetitions within individual key columns
    ## use ceiling() to ensure we cover u1Size; will truncate afterward
    u1SizePerKeyColumn <- as.integer(ceiling(u1Size^(1/3)));

    ## generate the unique key values for df1
    keys1 <- expand.grid(stringsAsFactors=F,
        idCharacter=replicate(u1SizePerKeyColumn,paste(collapse='',sample(letters,sample(4:12,1L),T))),
        idInteger=sample(u1SizePerKeyColumn),
        idLogical=sample(c(F,T),u1SizePerKeyColumn,T)
        ##idPOSIXct=as.POSIXct('2016-01-01 00:00:00','UTC')+sample(u1SizePerKeyColumn)
    )[seq_len(u1Size),];

    ## rbind some repetitions of the unique keys; this will prepare one side of the many-to-many relationship
    ## also scramble the order afterward
    keys1 <- rbind(keys1,keys1[sample(nrow(keys1),size-u1Size,T),])[sample(size),];

    ## common and unilateral key counts
    com <- as.integer(size*overlap);
    uni <- size-com;

    ## generate some unilateral keys for df2 by synthesizing outside of the idInteger range of df1
    keys2 <- data.frame(stringsAsFactors=F,
        idCharacter=replicate(uni,paste(collapse='',sample(letters,sample(4:12,1L),T))),
        idInteger=u1SizePerKeyColumn+sample(uni),
        idLogical=sample(c(F,T),uni,T)
        ##idPOSIXct=as.POSIXct('2016-01-01 00:00:00','UTC')+u1SizePerKeyColumn+sample(uni)
    );

    ## rbind random keys from df1; this will complete the many-to-many relationship
    ## also scramble the order afterward
    keys2 <- rbind(keys2,keys1[sample(nrow(keys1),com,T),])[sample(size),];

    ##keyNames <- c('idCharacter','idInteger','idLogical','idPOSIXct');
    keyNames <- c('idCharacter','idInteger','idLogical');
    ## note: was going to use raw and complex type for two of the non-key columns, but data.table doesn't seem to fully support them
    argSpecs <- list(
        default=list(copySpec=1:2,args=list(
            df1 <- cbind(stringsAsFactors=F,keys1,y1=sample(c(F,T),size,T),y2=sample(size),y3=rnorm(size),y4=replicate(size,paste(collapse='',sample(letters,sample(4:12,1L),T)))),
            df2 <- cbind(stringsAsFactors=F,keys2,y5=sample(c(F,T),size,T),y6=sample(size),y7=rnorm(size),y8=replicate(size,paste(collapse='',sample(letters,sample(4:12,1L),T)))),
            keyNames
        )),
        data.table.unkeyed=list(copySpec=1:2,args=list(
            as.data.table(df1),
            as.data.table(df2),
            keyNames
        )),
        data.table.keyed=list(copySpec=1:2,args=list(
            setkeyv(as.data.table(df1),keyNames),
            setkeyv(as.data.table(df2),keyNames)
        ))
    );
    ## prepare sqldf
    initSqldf();
    sqldf(paste0('create index df1_key on df1(',paste(collapse=',',keyNames),');')); ## upload and create an sqlite index on df1
    sqldf(paste0('create index df2_key on df2(',paste(collapse=',',keyNames),');')); ## upload and create an sqlite index on df2

    argSpecs;

}; ## end makeArgSpecs.assortedKey.optionalManyToMany()

sizes <- c(1e1L,1e3L,1e5L); ## 1e5L instead of 1e6L to respect more heavy-duty inputs
overlaps <- c(0.99,0.5,0.01);
solTypes <- setdiff(getSolTypes(),'in.place');
system.time({ res <- testGrid(makeArgSpecs.assortedKey.optionalManyToMany,sizes,overlaps,solTypes); });
##     user   system  elapsed
## 38895.50   784.19 39745.53

Los gráficos resultantes, utilizando el mismo código de trazado proporcionado anteriormente:

titleFunc <- function(overlap) sprintf('R merge solutions: character/integer/logical key, 0..*:0..* cardinality, %d%% overlap',as.integer(overlap*100));
plotRes(res,titleFunc,F);

R-merge-benchmark-assorted-key-optional-many-to-many-99

R-merge-benchmark-assorted-key-optional-many-to-many-50

R-merge-benchmark-assorted-key-optional-many-to-many-1

  1. Uso de la función merge podemos seleccionar la variable de tabla de la izquierda o la tabla de la derecha, igual como todos familiarizados con instrucción de selección en SQL (EX que: Seleccione un * ... o seleccione b * desde ....... )

  2. Hay que añadir código extra que será un subconjunto de la tabla recién incorporado.

    • SQL: - select a.* from df1 a inner join df2 b on a.CustomerId=b.CustomerId

    • R: - merge(df1, df2, by.x = "CustomerId", by.y = "CustomerId")[,names(df1)]

La misma manera

  • SQL: - select b.* from df1 a inner join df2 b on a.CustomerId=b.CustomerId

  • R: - merge(df1, df2, by.x = "CustomerId", by.y = "CustomerId")[,names(df2)]

Para una combinación interna en todas las columnas, se podría también utilizar fintersect de la data.table -El paquete o intersect de la dplyr -El paquete como una alternativa a merge sin especificando las by-columnas. esto dará las filas que son iguales entre dos tramas de datos: 

merge(df1, df2)
#   V1 V2
# 1  B  2
# 2  C  3
dplyr::intersect(df1, df2)
#   V1 V2
# 1  B  2
# 2  C  3
data.table::fintersect(setDT(df1), setDT(df2))
#    V1 V2
# 1:  B  2
# 2:  C  3

Ejemplo datos: 

df1 <- data.frame(V1 = LETTERS[1:4], V2 = 1:4)
df2 <- data.frame(V1 = LETTERS[2:3], V2 = 2:3)

Actualizar unirse. Otra unión importante de estilo SQL es "actualizar unirse" donde las columnas de una tabla se actualizan (o crean) utilizando otra tabla.

Modificando las tablas de ejemplo del OP...

sales = data.frame(
  CustomerId = c(1, 1, 1, 3, 4, 6), 
  Year = 2000:2005,
  Product = c(rep("Toaster", 3), rep("Radio", 3))
)
cust = data.frame(
  CustomerId = c(1, 1, 4, 6), 
  Year = c(2001L, 2002L, 2002L, 2002L),
  State = state.name[1:4]
)

sales
# CustomerId Year Product
#          1 2000 Toaster
#          1 2001 Toaster
#          1 2002 Toaster
#          3 2003   Radio
#          4 2004   Radio
#          6 2005   Radio

cust
# CustomerId Year    State
#          1 2001  Alabama
#          1 2002   Alaska
#          4 2002  Arizona
#          6 2002 Arkansas

Supongamos que queremos agregar el estado del cliente desde cust a la mesa de compras, sales, ignorando la columna del año.Con la base R, podemos identificar filas coincidentes y luego copiar valores:

sales$State <- cust$State[ match(sales$CustomerId, cust$CustomerId) ]

# CustomerId Year Product    State
#          1 2000 Toaster  Alabama
#          1 2001 Toaster  Alabama
#          1 2002 Toaster  Alabama
#          3 2003   Radio     <NA>
#          4 2004   Radio  Arizona
#          6 2005   Radio Arkansas

# cleanup for the next example
sales$State <- NULL

Como se puede ver aquí, match selecciona la primera fila coincidente de la tabla de clientes.

Actualizar unión con varias columnas. El enfoque anterior funciona bien cuando nos unimos en una sola columna y estamos satisfechos con la primera coincidencia.Supongamos que queremos que el año de medición en la tabla de clientes coincida con el año de venta.

Como menciona la respuesta de @bgoldst, match con interaction podría ser una opción para este caso.De manera más sencilla, se podría usar data.table:

library(data.table)
setDT(sales); setDT(cust)

sales[, State := cust[sales, on=.(CustomerId, Year), x.State]]

#    CustomerId Year Product   State
# 1:          1 2000 Toaster    <NA>
# 2:          1 2001 Toaster Alabama
# 3:          1 2002 Toaster  Alaska
# 4:          3 2003   Radio    <NA>
# 5:          4 2004   Radio    <NA>
# 6:          6 2005   Radio    <NA>

# cleanup for next example
sales[, State := NULL]

Únase a la actualización continua. Como alternativa, es posible que deseemos tomar el último estado en el que se encontró al cliente:

sales[, State := cust[sales, on=.(CustomerId, Year), roll=TRUE, x.State]]

#    CustomerId Year Product    State
# 1:          1 2000 Toaster     <NA>
# 2:          1 2001 Toaster  Alabama
# 3:          1 2002 Toaster   Alaska
# 4:          3 2003   Radio     <NA>
# 5:          4 2004   Radio  Arizona
# 6:          6 2005   Radio Arkansas

Los tres ejemplos anteriores se centran en crear/agregar una nueva columna.Ver las preguntas frecuentes relacionadas con R para ver un ejemplo de actualización/modificación de una columna existente.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top