[Sequelize] Join (sequelize-typescript)

시퀄라이즈의 ORM 기능을 통해 join을 수행하는 방법을 천천히 다뤄보겠다.
ORM은 단순 CRUD 작업에서 특출난 생산성을 보이지만, 단순한 형태의 Join 또한 익숙하다는 전제하에서 깔끔한 코드와 괜찮은 생산성을 보여준다,

일단 사용자를 뜻하는 "User" 엔티티와

사용자가 작성한 게시글을 나타내는 "Post" 엔티티 2개를 기반으로 테스트를 한번 해보겠다.

@BelongsTo 관계

저기서 만약 게시글을 가져오되, 그 게시글을 작성한 사용자까지 함께 가져오려면 어떻게 해야할까?

관계적으로 생각하면 사용자가 게시글을 작성했으니 게시글은 사용자에게 속해있다고 할 수 있다.
그리고 게시글은 작성한 사용자의 고유키를 컬럼으로 보유하는 것으로 그 소속성을 증명한다.

이런 경우에는 BelongsTo 관계를 사용하면 된다.
외래키 컬럼에 ForeignKey 데코레이터로 해당 사용자 모델을 참조하는 키임을 명시해준다.
해당 모델을 반환하는 클로저를 넘겨주면 된다.

그리고 컬럼이 아닌 BelongsTo 필드로 조인해온 값을 담아둘 필드를 지정해준다.
BelongsTo에는 사용자 모델을 넣어주고, 필드의 타입은 모델타입이나 그거랑 매핑되는 객체 타입을 아무거나 넣어주면 된다.

그럼 이제 이런식으로 Join 수행이 가능해진다.
join은 기본적으로 find 메서드들의 include 옵션을 통해 수행하는데, model에 User를 넣어주면 된다.

그럼 아래와 같이 쿼리가 뽑혀서 실행될 것이다.

보기 힘드니 정렬해서 보자

 select
	"Post"."id",
	"Post"."userId",
	"Post"."title",
	"Post"."content",
	"Post"."useYn",
	"Post"."createdAt",
	"Post"."updatedAt",
	"user"."id" as "user.id",
	"user"."email" as "user.email",
	"user"."password" as "user.password",
	"user"."passwordSalt" as "user.passwordSalt",
	"user"."name" as "user.name",
	"user"."userType" as "user.userType",
	"user"."userStatus" as "user.userStatus",
	"user"."createdAt" as "user.createdAt",
	"user"."updatedAt" as "user.updatedAt"
from
	"Posts" as "Post"
left outer join "Users" as "user" on
	"Post"."userId" = "user"."id"
where
	"Post"."useYn" = true;

left 조인에 User의 고유키로 조건을 걸어서 잘 가져오는 것을 확인할 수 있다.

내부&외부조인 설정

위의 BelongsTo로 돌린 쿼리의 경우에는 기본적으로 Left 외부조인을 수행했다.
하지만 내부조인으로 돌리고 싶을 수도 있지 않겠는가?
이런 경우에는 required 옵션값을 true로 주면 내부조인을 수행한다.
반대로 false를 주면 외부조인을 수행한다.

select
	"Post"."id",
	"Post"."userId",
	"Post"."title",
	"Post"."content",
	"Post"."useYn",
	"Post"."createdAt",
	"Post"."updatedAt",
	"user"."id" as "user.id",
	"user"."email" as "user.email",
	"user"."password" as "user.password",
	"user"."passwordSalt" as "user.passwordSalt",
	"user"."name" as "user.name",
	"user"."userType" as "user.userType",
	"user"."userStatus" as "user.userStatus",
	"user"."createdAt" as "user.createdAt",
	"user"."updatedAt" as "user.updatedAt"
from
	"Posts" as "Post"
inner join "Users" as "user" on
	"Post"."userId" = "user"."id"
where
	"Post"."useYn" = true
order by
	"Post"."createdAt" desc
limit 10 offset 0;

On 절 설정

join문의 on 절에 추가 조건절을 추가하고 싶다면 where 옵션값을 사용한다.
그러면 기본 on 절에 더해서 조건을 더해줄 것이다.

이렇게

select
	"Post"."id",
	"Post"."userId",
	"Post"."title",
	"Post"."content",
	"Post"."useYn",
	"Post"."createdAt",
	"Post"."updatedAt",
	"user"."id" as "user.id",
	"user"."email" as "user.email",
	"user"."password" as "user.password",
	"user"."passwordSalt" as "user.passwordSalt",
	"user"."name" as "user.name",
	"user"."userType" as "user.userType",
	"user"."userStatus" as "user.userStatus",
	"user"."createdAt" as "user.createdAt",
	"user"."updatedAt" as "user.updatedAt"
from
	"Posts" as "Post"
inner join "Users" as "user" on
	"Post"."userId" = "user"."id"
	and "user"."userStatus" = 0
where
	"Post"."useYn" = true
order by
	"Post"."createdAt" desc
limit 10 offset 0;

그런데 저런 자동 매핑이 지겨워져서 join 조건을 직접 다 지정하고 싶을 수도 있다.
그럴 때는 on 옵션으로 조건을 지정하면 된다.
이걸 쓰면 자동으로 생성되는 on 절이 제거되고 우리가 넣은 것만 조건으로 들어간다.

select
	"Post"."id",
	"Post"."userId",
	"Post"."title",
	"Post"."content",
	"Post"."useYn",
	"Post"."createdAt",
	"Post"."updatedAt",
	"user"."id" as "user.id",
	"user"."email" as "user.email",
	"user"."password" as "user.password",
	"user"."passwordSalt" as "user.passwordSalt",
	"user"."name" as "user.name",
	"user"."userType" as "user.userType",
	"user"."userStatus" as "user.userStatus",
	"user"."createdAt" as "user.createdAt",
	"user"."updatedAt" as "user.updatedAt"
from
	"Posts" as "Post"
left outer join "Users" as "user" on
	"user"."id" = "Post"."userId"
	and "user"."userStatus" = 0
where
	"Post"."useYn" = true
order by
	"Post"."createdAt" desc
limit 10 offset 0;

Join 중첩

다른 테이블은 한번 조인했는데, 조인한 테이블에서 또 조인을 해오고 싶을 수 있다.
그럴 때는 해당 include 절에 또 include를 재귀적으로 정의하면 된다.

HasOne 관계

이번엔 사용자의 관점으로 돌아가보자.
일반적이지는 않지만, 사용자를 기반으로 해서 사용자가 소유한 하나의 게시글을 가져오는 쿼리를 작성해보겠다.

게시글은 사용자가 작성한 것이고 사용자에게 속해있으니, 사용자는 게시글을 가지고 있다고 볼 수 있다.

현재 중심이 될 사용자는 게시글에 대한 참조속성을 가지고 있지는 않지만, 속해있는 게시글 엔티티 Post가 참조속성을 갖고 있기에 성립할 수 있는 관계다.

이번엔 이걸 이용해서 사용자 조회시에 게시글도 하나 가져오도록 해보겠다.
다음과 같이 관계를 명시해주고

include만 똑바로 써주면 된다.

그럼 아래와 같이 쿼리가 뽑혀서

select
	"User"."id",
	"User"."email",
	"User"."password",
	"User"."passwordSalt",
	"User"."name",
	"User"."userType",
	"User"."userStatus",
	"User"."createdAt",
	"User"."updatedAt",
	"post"."id" as "post.id",
	"post"."userId" as "post.userId",
	"post"."title" as "post.title",
	"post"."content" as "post.content",
	"post"."useYn" as "post.useYn",
	"post"."createdAt" as "post.createdAt",
	"post"."updatedAt" as "post.updatedAt"
from
	"Users" as "User"
left outer join "Posts" as "post" on
	"User"."id" = "post"."userId"
where
	"User"."id" = 1
	and "User"."userStatus" = 0;

예쁘게 잘 출력될 것이다.

HasMany 관계

사용자의 관점에서, 사용자는 아마 여러개의 게시글을 쓸 수 있을 것이다.
따라서 사용자는 여러개의 게시글을 소유하고 있다고 할 수 있다.

HasOne에서 그대로 복수형만 된 개념이다.
이번에는 사용자를 가져옴과 동시에 사용자가 갖고있는 게시글을 전부 가져올 수 있도록 해보겠다.
HasMany로 달고, 필드의 타입을 배열로 설정한다.

그리고 이전과 동일하게 findOne 코드를 작성한다.

그럼 다음과 같이 쿼리가 뽑힐 것이고

select
	"User"."id",
	"User"."email",
	"User"."password",
	"User"."passwordSalt",
	"User"."name",
	"User"."userType",
	"User"."userStatus",
	"User"."createdAt",
	"User"."updatedAt",
	"posts"."id" as "posts.id",
	"posts"."userId" as "posts.userId",
	"posts"."title" as "posts.title",
	"posts"."content" as "posts.content",
	"posts"."useYn" as "posts.useYn",
	"posts"."createdAt" as "posts.createdAt",
	"posts"."updatedAt" as "posts.updatedAt"
from
	"Users" as "User"
left outer join "Posts" as "posts" on
	"User"."id" = "posts"."userId"
where
	"User"."id" = 1
	and "User"."userStatus" = 0;

이렇게 의도한대로 잘 나올 것이다.

동일 엔티티 외래키가 여러개일 경우

사용자가 다른 사용자를 신고할 경우의 데이터 관리를 생각해보자.
그럼 대충 다음과 같이 신고한 사람과, 신고당한 사람의 식별자를 갖게 될 것이다.

엔티티 정의와 사용은 단순하게 생각한다면 이런식으로 해볼 수 있을 것이다.

그럼 에러가 난다.
sendUser와 targetUser를 어떤 키로 조인하고, alias를 어떻게 할지 알지 못하기 때문이다.

이럴 때는 매핑되는 관계 데코레이터에 참조하는 외래키와 테이블 alias를 옵션으로 줘야 한다.

그리고 find할때도 지정한 as를 맞춰주면 끝이다.

그럼 쿼리가 이렇게 뽑혀서

SELECT
	"Report"."id",
	"Report"."sendUserId",
	"Report"."targetUserId",
	"Report"."reason",
	"Report"."createdAt",
	"Report"."updatedAt",
	"sendUser"."id" AS "sendUser.id",
	"sendUser"."email" AS "sendUser.email",
	"sendUser"."password" AS "sendUser.password",
	"sendUser"."passwordSalt" AS "sendUser.passwordSalt",
	"sendUser"."name" AS "sendUser.name",
	"sendUser"."userType" AS "sendUser.userType",
	"sendUser"."userStatus" AS "sendUser.userStatus",
	"sendUser"."createdAt" AS "sendUser.createdAt",
	"sendUser"."updatedAt" AS "sendUser.updatedAt",
	"targetUser"."id" AS "targetUser.id",
	"targetUser"."email" AS "targetUser.email",
	"targetUser"."password" AS "targetUser.password",
	"targetUser"."passwordSalt" AS "targetUser.passwordSalt",
	"targetUser"."name" AS "targetUser.name",
	"targetUser"."userType" AS "targetUser.userType",
	"targetUser"."userStatus" AS "targetUser.userStatus",
	"targetUser"."createdAt" AS "targetUser.createdAt",
	"targetUser"."updatedAt" AS "targetUser.updatedAt"
FROM
	"Reports" AS "Report"
LEFT OUTER JOIN "Users" AS "sendUser" ON
	"Report"."sendUserId" = "sendUser"."id"
LEFT OUTER JOIN "Users" AS "targetUser" ON
	"Report"."targetUserId" = "targetUser"."id";

잘 가져올 것이다.

BelongsToMany 관계: 다대다 관계 매핑

여기서는 조금 어렵게 느낄 수도 있다.

일반적인 쇼핑몰의 구조를 고려해본다면, 사용자와 상품이라는 가장 중심 모델이 존재할 것이다.

사용자가 상품을 구매하면 뭔가 관계를 통해서 연결해야 하지만, 사용자도 상품에게 종속적이지 않고 상품도 사용자에게 종속적이지 않다.
한 상품도 여러명의 사용자에게 구매될 수 있고, 한 사용자도 여러개의 상품을 구매할 수 있기 때문이다.

그래서 이러한 다대다 관계를 매핑할 때는 "UserProduct" 같은 관계용 매핑 테이블을 만들어서 사용자와 상품의 고유키를 엮어 사용하곤 한다.

한번 써보자.
User에 더해 Product 엔티티를 추가로 정의하고

매핑용 테이블을 정의한다.
각 테이블의 외래키를 가지도록 했다.

그럼 이제 사용자를 기준으로 해서 구매한 상품을 가져오는 쿼리를 돌려보겠다.
BelongsToMany로 Product를 반환하는 클로저, 매핑 테이블을 반환하는 클로저를 전달한다.

그럼 이렇게 단순하게 가져올 수 있다.

쿼리는 이렇게 뽑히고

select
	"User"."id",
	"User"."email",
	"User"."password",
	"User"."passwordSalt",
	"User"."name",
	"User"."userType",
	"User"."userStatus",
	"User"."createdAt",
	"User"."updatedAt",
	"products"."id" as "products.id",
	"products"."name" as "products.name",
	"products"."price" as "products.price",
	"products"."createdAt" as "products.createdAt",
	"products"."updatedAt" as "products.updatedAt",
	"products->UserProduct"."id" as "products.UserProduct.id",
	"products->UserProduct"."userId" as "products.UserProduct.userId",
	"products->UserProduct"."productId" as "products.UserProduct.productId",
	"products->UserProduct"."createdAt" as "products.UserProduct.createdAt",
	"products->UserProduct"."updatedAt" as "products.UserProduct.updatedAt"
from
	"Users" as "User"
left outer join ( "UserProducts" as "products->UserProduct"
inner join "Products" as "products" on
	"products"."id" = "products->UserProduct"."productId") on
	"User"."id" = "products->UserProduct"."userId";

가져오기도 잘 가져올 것이다.

상품을 기준으로 할 때도 마찬가지다.
반대로만 해주면 된다.

그럼 이렇게 잘 가져올 것이다.

 select
	"Product"."id",
	"Product"."name",
	"Product"."price",
	"Product"."createdAt",
	"Product"."updatedAt",
	"users"."id" as "users.id",
	"users"."email" as "users.email",
	"users"."password" as "users.password",
	"users"."passwordSalt" as "users.passwordSalt",
	"users"."name" as "users.name",
	"users"."userType" as "users.userType",
	"users"."userStatus" as "users.userStatus",
	"users"."createdAt" as "users.createdAt",
	"users"."updatedAt" as "users.updatedAt",
	"users->UserProduct"."id" as "users.UserProduct.id",
	"users->UserProduct"."userId" as "users.UserProduct.userId",
	"users->UserProduct"."productId" as "users.UserProduct.productId",
	"users->UserProduct"."createdAt" as "users.UserProduct.createdAt",
	"users->UserProduct"."updatedAt" as "users.UserProduct.updatedAt"
from
	"Products" as "Product"
left outer join ( "UserProducts" as "users->UserProduct"
inner join "Users" as "users" on
	"users"."id" = "users->UserProduct"."userId") on
	"Product"."id" = "users->UserProduct"."productId";

그렇다.

참조
https://sequelize.org/master/manual/eager-loading.html
https://gist.github.com/zcaceres/83b554ee08726a734088d90d455bc566
https://velog.io/@cadenzah/sequelize-document-4