데이터 프레임(내부, 외부, 왼쪽, 오른쪽)을 결합(병합)하는 방법
https://stackoverflow.com/questions/1299871
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
두 개의 데이터 프레임이 주어지면:
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
데이터베이스 스타일을 어떻게 수행할 수 있습니까? SQL 스타일, 조인?즉, 어떻게 얻을 수 있습니까?
- 안 내부 조인 ~의
df1그리고df2:
왼쪽 테이블과 오른쪽 테이블의 일치하는 키가 있는 행만 반환합니다. - 안 외부 조인 ~의
df1그리고df2:
두 테이블의 모든 행을 반환하고 오른쪽 테이블에 일치하는 키가 있는 왼쪽의 레코드를 조인합니다. - ㅏ 왼쪽 외부 조인(또는 단순히 왼쪽 조인) ~의
df1그리고df2
왼쪽 테이블의 모든 행을 반환하고 오른쪽 테이블의 일치하는 키가 있는 모든 행을 반환합니다. - ㅏ 오른쪽 외부 조인 ~의
df1그리고df2
오른쪽 테이블의 모든 행을 반환하고 왼쪽 테이블의 일치하는 키가 있는 모든 행을 반환합니다.
추가 크레딧:
SQL 스타일 선택 문을 어떻게 수행할 수 있나요?
해결책
사용함으로써 merge 함수 및 선택적 매개 변수 :
내부 조인 : merge(df1, df2) R은 일반적인 변수 이름으로 프레임을 자동으로 결합하기 때문에 이러한 예제에 대해 작동하지만 지정할 가능성이 높습니다. merge(df1, df2, by = "CustomerId") 당신이 원하는 필드에만 일치하고 있는지 확인하기 위해. 당신은 또한 사용할 수 있습니다 by.x 그리고 by.y 매개 변수가 일치하는 변수가 다른 데이터 프레임에 다른 이름을 갖는 경우.
외부 조인 : merge(x = df1, y = df2, by = "CustomerId", all = TRUE)
왼쪽 외부 : merge(x = df1, y = df2, by = "CustomerId", all.x = TRUE)
바깥 쪽 바깥 : merge(x = df1, y = df2, by = "CustomerId", all.y = TRUE)
크로스 조인 : merge(x = df1, y = df2, by = NULL)
내부 조인과 마찬가지로, 당신은 아마도 "customerID"를 일치 변수로 명시 적으로 통과하고 싶을 것입니다. 합병하려는 식별자를 명시 적으로 명시하는 것이 거의 항상 최선이라고 생각합니다. 입력 데이터가 예기치 않게 변경되고 나중에 읽을 수있는 것이 더 안전합니다.
기부하여 여러 열에 병합 할 수 있습니다 by 벡터, 예를 들어, by = c("CustomerId", "OrderId").
병합 할 열 이름이 동일하지 않은 경우, 예를 들어 지정할 수 있습니다. by.x = "CustomerId_in_df1", by.y = "CustomerId_in_df2" 어디 CustomerId_in_df1 첫 번째 데이터 프레임의 열 이름이며 CustomerId_in_df2 두 번째 데이터 프레임의 열 이름입니다. (여러 열에서 병합 해야하는 경우 벡터 일 수도 있습니다.)
다른 팁
체크 아웃하는 것이 좋습니다 Gabor Grothendieck의 SQLDF 패키지, 이러한 작업을 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)")
SQL 구문이 R 등가보다 단순하고 자연 스럽다는 것을 알게됩니다 (그러나 이것은 내 RDBMS 바이어스를 반영 할 수 있습니다).
보다 Gabor의 sqldf github 조인에 대한 자세한 내용은.
거기에 있습니다 데이터 내부 조인에 대한 접근 방식은 매우 시간과 메모리 효율적입니다 (그리고 일부 더 큰 데이터에 필요) :.
library(data.table)
dt1 <- data.table(df1, key = "CustomerId")
dt2 <- data.table(df2, key = "CustomerId")
joined.dt1.dt.2 <- dt1[dt2]
merge 또한 data.tables (일반 및 통화로서)에서도 작동합니다. merge.data.table)
merge(dt1, dt2)
stackoverflow에 문서화 된 데이터.
데이터를 수행하는 방법 테이블 병합 작업
SQL 번역 외부 키에서 R Data.table 구문으로 조인
더 큰 데이터에 병합하기위한 효율적인 대안 r
기본 왼쪽 외부 OUTER 조인을 데이터와 함께 사용하는 방법은 r에서 table?
또 다른 옵션은 join 에서 발견 된 함수 Plyr 패키지
library(plyr)
join(df1, df2,
type = "inner")
# CustomerId Product State
# 1 2 Toaster Alabama
# 2 4 Radio Alabama
# 3 6 Radio Ohio
옵션 type: inner, left, right, full.
에서 ?join:와 달리 merge, [join] 어떤 결합 유형을 사용하든 X의 순서가 보존됩니다.
Hadley Wickham 's Awesome을 사용하여 합류 할 수 있습니다. dplyr 패키지.
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)
변이 결합 : DF2의 일치를 사용하여 DF1에 열을 추가합니다.
#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)
필터링 조인 : DF1에서 행을 필터링하고 열을 수정하지 마십시오.
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.
이 작업을 수행하는 몇 가지 좋은 예가 있습니다. R 위키. 나는 여기에 부부를 훔칠 것이다 :
병합 방법
키가 동일하게 이름이 지정되므로 내부 조인을 수행하는 짧은 방법은 merge ()입니다.
merge(df1,df2)
전체 내부 조인 (두 테이블의 모든 레코드)은 "모든"키워드로 만들 수 있습니다.
merge(df1,df2, all=TRUE)
DF1 및 DF2의 왼쪽 외부 조인 :
merge(df1,df2, all.x=TRUE)
DF1 및 DF2의 오른쪽 외부 조인 :
merge(df1,df2, all.y=TRUE)
당신은 당신이 요청한 다른 두 개의 외부 결합을 얻기 위해 뒤집고, 때리고, 문지르고, :)
첨자 방법
첨자 방법을 사용하여 왼쪽의 DF1과 왼쪽 외부 조인은 다음과 같습니다.
df1[,"State"]<-df2[df1[ ,"Product"], "State"]
외부 결합의 다른 조합은 왼쪽 OUTER 조인 첨자 예제를 연마하여 생성 할 수 있습니다. (그래, 나는 그것이 "독자를위한 운동으로 남겨 두게 될 것입니다 ...")라고 말하는 것과 같습니다.
2014 년 새로운 :
특히 일반적으로 데이터 조작에 관심이 있다면 (정렬, 필터링, 하위 설정, 요약 등) 분명히 살펴 봐야합니다. dplyr, 데이터 프레임 및 기타 특정 데이터베이스 유형으로 구체적으로 작업을 용이하게하도록 설계된 다양한 기능이 제공됩니다. 심지어 정교한 SQL 인터페이스를 제공하고 (대부분의) SQL 코드를 직접 변환하는 함수조차도 제공합니다.
DPLYR 패키지의 4 가지 결합 관련 기능은 다음과 같습니다.
inner_join(x, y, by = NULL, copy = FALSE, ...): y에 일치하는 값이있는 x에서 x와 y의 모든 열이있는 x에서 모든 행을 반환합니다.left_join(x, y, by = NULL, copy = FALSE, ...): x에서 모든 행을 반환하고 x와 y의 모든 열을 반환합니다.semi_join(x, y, by = NULL, copy = FALSE, ...): x에서 일치하는 값이있는 x에서 모든 행을 x에서 x에서 단지 유지합니다.anti_join(x, y, by = NULL, copy = FALSE, ...): y의 값이 일치하지 않는 경우 x에서 모든 행을 반환하고 x에서 열만 유지합니다.
그게 다야 여기 자세히.
열 선택은 다음과 같이 수행 할 수 있습니다 select(df,"column"). 그것이 당신을 위해 충분히 SQL-ish가 아니라면 sql() 기능, SQL 코드를 입력 할 수있는 함수는 as-is-is를 입력 할 수 있으며 R에 글을 쓰는 것처럼 지정한 작업을 수행합니다 (자세한 내용은 참조하십시오. 참조하십시오. dplyr/database vignette). 예를 들어, 올바르게 적용되면 sql("SELECT * FROM hflights") "hflights"dplyr 테이블 (A "TBL")에서 모든 열을 선택합니다.
데이터 세트 조인을 위한 data.table 메서드 업데이트.각 조인 유형에 대한 아래 예를 참조하세요.두 가지 방법이 있습니다. [.data.table 두 번째 data.table을 하위 집합의 첫 번째 인수로 전달할 때 또 다른 방법은 다음을 사용하는 것입니다. merge 빠른 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
아래 벤치마크 테스트는 R, sqldf, dplyr 및 data.table을 기반으로 합니다.
벤치마크는 키가 지정되지 않은/인덱싱되지 않은 데이터 세트를 테스트합니다.벤치마크는 50M-1 행 데이터 세트에서 수행되며 조인 열에는 50M-2 공통 값이 있으므로 각 시나리오(내부, 왼쪽, 오른쪽, 전체)를 테스트할 수 있으며 조인은 여전히 수행하기 쉽지 않습니다.조인 알고리즘을 강조하는 조인 유형입니다.타이밍은 다음과 같습니다 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
다음을 사용하여 수행할 수 있는 다른 유형의 조인이 있습니다. data.table:
- 가입 시 업데이트 - 다른 테이블의 값을 기본 테이블로 조회하려는 경우
- 조인 시 집계 - 조인 중인 키를 집계하려는 경우 모든 조인 결과를 구체화할 필요는 없습니다.
- 중복 조인 - 범위별로 병합하려는 경우
- 롤링 조인 - 병합을 앞/뒤 행의 값을 앞뒤로 롤링하여 일치시킬 수 있도록 하려는 경우
- 비동등 조인 - 가입 조건이 동일하지 않은 경우
재현할 코드:
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
0.4가 포함 된 이후 DPLYR outer_join, 그러나 그것은 주목할 가치가있었습니다 0.4 이전에 처음 몇 번의 릴리스에 대해서는 제공하지 않았습니다. outer_join, 결과적으로, 그 결과 꽤 오랫동안 꽤 오랫동안 떠 다니는 정말 나쁜 해킹 된 해결 방법 사용자 코드가 많이있었습니다. )
가입 관련 릴리스 하이라이트:
- posixct 유형, 시간 존, 복제, 다른 요인 수준에 대한 처리. 더 나은 오류와 경고.
- 접미사 복제 된 변수 이름을 통제하기위한 새로운 접미사 인수 (#1296)
- 올바른 조인 및 외부 조인을 구현하십시오 (#96)
- 돌연변이 결합은 다른 행의 일치 행에서 한 테이블에 새로운 변수를 추가합니다. 필터링 결합은 다른 테이블의 관찰과 일치하는지 여부를 기반으로 한 테이블의 관찰을 필터링합니다.
- 이제 각 테이블의 다른 변수에 의해 왼쪽_join 할 수 있습니다 : df1 %> % left_join (df2, c ( "var1"= "var2"))
- *_join ()은 더 이상 열 이름을 다시 표시하지 않습니다 (#324)
v0.1.3 (4/2014)
- 가지다 inner_join, left_join, semi_join, anti_join
- outer_join 아직 구현되지 않은 폴백은 사용베이스 :: merge (또는 plyr :: join ())입니다.
- 아직 Right_Join을 구현하십시오 outer_join
- Hadley는 여기에 다른 장점을 언급합니다
- 현재 DPYR이 By.x, by.y 열을 가질 수있는 기능 Python Pandas는 예를 들어.
해당 문제에서 Hadley의 의견마다 해결 방법 :
- right_join(x, y)는 행의 관점에서 Left_join (y, x)과 동일하며 열은 다른 순서가됩니다. Select (new_column_order)와 쉽게 작업했습니다.
- outer_join 기본적으로 Union (left_join (x, y), right_join (x, y)) - 즉 두 데이터 프레임의 모든 행을 보존합니다.
각각 ~ 1 백만 행으로 두 개의 데이터 프레임을 결합 할 때, 하나는 2 개의 열이 있고 다른 하나는 ~ 20인데, 놀랍게도 발견했습니다. merge(..., all.x = TRUE, all.y = TRUE) 더 빨리 dplyr::full_join(). 이것은 dplyr v0.4입니다
병합은 ~ 17 초, full_join은 ~ 65 초가 걸립니다.
그래도 조작 작업을 위해 일반적으로 dplyr로 기본적으로 기본적으로 음식을 제공합니다.
왼쪽 가입의 경우 a 0..*:0..1 카디널리티 또는 올바른 가입 a 0..1:0..* 카디널리 성 결합너 ( 0..1 테이블) 직접 joinee (the 0..* 표), 따라서 완전히 새로운 데이터 테이블의 생성을 피하십시오. 이를 위해서는 joinee의 키 열을 Joiner와 일치시키고 할당에 따라 Joiner의 행을 주문하고 인덱싱해야합니다.
키가 단일 열인 경우 단일 호출을 사용할 수 있습니다. match() 일치하는 일을합니다. 이 답변에서 다룰 경우입니다.
추가 행을 추가 한 것을 제외하고는 OP를 기반으로 한 예입니다. df2 조이너에서 일치하지 않는 키의 경우를 테스트하기 위해 ID 7의 경우. 이것은 효과적입니다 df1 왼쪽 가입 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
위의 i는 키 열이 두 입력 테이블의 첫 번째 열이라는 가정을 하드 코딩했습니다. 일반적으로 이것은 비합리적인 가정이 아니라고 주장합니다. 키 열이있는 데이터가 있으면 Data.frame의 첫 번째 열로 설정되지 않았다면 이상 할 것입니다. 처음. 그리고 항상 열을 재정렬하여 그렇게 할 수 있습니다. 이 가정의 유리한 결과는 키 열의 이름이 하드 코딩 될 필요는 없지만 한 가정을 다른 가정으로 대체한다고 생각합니다. Concision은 정수 인덱싱의 또 다른 장점과 속도입니다. 아래 벤치 마크에서는 경쟁 구현과 일치하기 위해 String Name Indexing을 사용하도록 구현을 변경하겠습니다.
단일 큰 테이블에 가입하려는 테이블이 여러 개있는 경우 특히 적절한 솔루션이라고 생각합니다. 각 병합에 대한 전체 테이블을 반복적으로 재건하는 것은 불필요하고 비효율적입니다.
반면에, 어떤 이유로 든이 작업을 통해 변경되지 않은 상태로 유지하려면이 솔루션을 직접 수정 하므로이 솔루션을 사용할 수 없습니다. 이 경우 사본을 만들고 사본에서 내부 할당을 수행 할 수 있습니다.
부수적으로, 나는 다색 키를위한 가능한 매칭 솔루션을 간단히 살펴 보았습니다. 불행히도, 내가 찾은 유일한 일치 솔루션은 다음과 같습니다.
- 비효율적 인 연결. 예를 들어
match(interaction(df1$a,df1$b),interaction(df2$a,df2$b)), 또는 같은 아이디어paste(). - 비효율적 인 직교 결합, 예를 들어
outer(df1$a,df2$a,`==`) & outer(df1$b,df2$b,`==`). - 기본 r
merge()그리고 동등한 패키지 기반 병합 함수는 항상 새로운 테이블을 할당하여 병합 된 결과를 반환하므로 현장 할당 기반 솔루션에 적합하지 않습니다.
예를 들어, 참조하십시오 다른 데이터 프레임에서 여러 열을 일치시키고 결과적으로 다른 열을 얻습니다., 두 열의 다른 열과 일치시킵니다, 여러 열에서 일치합니다, 그리고 내가 원래 내장 솔루션을 생각해 낸이 질문의 속임수. R에서 두 개의 데이터 프레임을 다른 행으로 결합합니다..
벤치마킹
나는 내 벤치마킹을하기로 결정했다.
테스트 코드 :
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()
다음은 이전에 보여준 OP를 기반으로 한 예제의 벤치 마크입니다.
## 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
여기서 나는 임의의 입력 데이터를 벤치마킹하여 두 입력 테이블 사이의 다른 스케일과 다른 키 오버랩 패턴을 시도합니다. 이 벤치 마크는 여전히 단일 열 정수 키의 경우로 제한됩니다. 또한 내면 솔루션이 동일한 테이블의 왼쪽 및 오른쪽 결합에 모두 작동하도록하기 위해 모든 임의의 테스트 데이터가 사용합니다. 0..1:0..1 카디널리티. 이것은 두 번째 data.frame의 키 열을 생성 할 때 첫 번째 data.frame의 키 열을 교체하지 않고 샘플링하여 구현됩니다.
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
위의 결과의 로그 로그 플롯을 만들기 위해 몇 가지 코드를 작성했습니다. 각 오버랩 백분율에 대해 별도의 플롯을 생성했습니다. 약간 혼란 스럽지만 모든 솔루션 유형과 동일한 플롯에 표시되는 유형이있는 것을 좋아합니다.
스플라인 보간을 사용하여 개별 PCH 기호로 그려진 각 솔루션/조인 유형 조합에 대한 부드러운 곡선을 보여주었습니다. 결합 유형은 PCH 기호로 캡처되며 왼쪽 및 오른쪽의 내부, 왼쪽 및 직각 브래킷의 점을 사용하고 다이아몬드가 전체적으로 캡처됩니다. 솔루션 유형은 범례에 표시된대로 색상으로 캡처됩니다.
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);
추기경뿐만 아니라 주요 열의 수와 유형과 관련하여 더 많은 규모의 두 번째 대규모 벤치 마크가 있습니다. 이 벤치 마크의 경우 카디널리티에 제한이없는 하나의 문자, 하나의 정수 및 1 개의 논리적 인 세 가지 주요 열을 사용합니다 (즉, 0..*:0..*). (일반적으로 부동 소수점 비교 합병증으로 인해 이중 또는 복잡한 값으로 키 열을 정의하는 것은 바람직하지 않으며 기본적으로 기본적으로 아무도 원시 유형을 사용하지 않으므로 키에 해당 유형을 포함시키지 않았습니다. 칼럼. 또한 정보를 위해 POSIXCT 키 열을 포함하여 4 개의 키 열을 사용하려고 시도했지만 POSIXCT 유형은 sqldf.indexed 솔루션은 어떤 이유로 든, 아마도 부동 소수점 비교 이상으로 인해 제거되었으므로 제거했습니다.)
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
위에 주어진 동일한 플로팅 코드를 사용하여 결과 플롯 :
titleFunc <- function(overlap) sprintf('R merge solutions: character/integer/logical key, 0..*:0..* cardinality, %d%% overlap',as.integer(overlap*100));
plotRes(res,titleFunc,F);
- 사용
merge함수 우리는 SQL에서 select 문에 익숙한 왼쪽 테이블 또는 오른쪽 테이블의 변수를 선택할 수 있습니다 (예 : a.* ... 또는 select b.* from .....) 새로 결합 된 테이블에서 서브셋 될 추가 코드를 추가해야합니다.
SQL :-
select a.* from df1 a inner join df2 b on a.CustomerId=b.CustomerIdR :-
merge(df1, df2, by.x = "CustomerId", by.y = "CustomerId")[,names(df1)]
같은 길
SQL :-
select b.* from df1 a inner join df2 b on a.CustomerId=b.CustomerIdR :-
merge(df1, df2, by.x = "CustomerId", by.y = "CustomerId")[,names(df2)]
모든 열에서 내부 조인을 위해 사용할 수도 있습니다. fintersect ~로부터 데이터-패키지 또는 intersect ~로부터 dplyr-대안으로 포장 merge 지정하지 않고 by-Columns. 이것은 두 데이터 프레임 사이에 동일한 행을 제공합니다.
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
예제 :
df1 <- data.frame(V1 = LETTERS[1:4], V2 = 1:4)
df2 <- data.frame(V1 = LETTERS[2:3], V2 = 2:3)
업데이트 조인. 다른 중요한 SQL 스타일 조인은 "업데이트 조인"한 테이블의 열이 다른 테이블을 사용하여 업데이트 (또는 생성)되는 경우.
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
고객의 상태를 추가하고 싶다고 가정합니다. cust 구매 테이블에 sales, 올해 열 무시. 기본 R을 사용하면 일치하는 행을 식별 한 다음 값을 복사 할 수 있습니다.
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
여기에서 볼 수 있듯이 match 고객 테이블에서 첫 번째 일치 행을 선택합니다.
여러 열과 함께 업데이트합니다. 위의 접근 방식은 단일 열에 만 합류 할 때 잘 작동하며 첫 경기에 만족합니다. 고객 테이블의 측정 연도가 판매 연도와 일치하기를 원한다고 가정 해 봅시다.
@bgoldst의 답변에서 언급 한 것처럼 match ~와 함께 interaction 이 경우 옵션 일 수 있습니다. 보다 간단하게, 데이터를 사용할 수 있습니다.
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]
롤링 업데이트 조인. 또는 고객이 발견 한 마지막 상태를 취할 수 있습니다.
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
무엇보다도 세 가지 예는 새 열을 작성/추가하는 데 중점을 둡니다. 보다 관련 r faq 기존 열을 업데이트/수정하는 예.
