Rust에서의 Concurrent Database Connection과 쿼리 실행

/// [GET /room/comment?offset=0&limit=10?is_user=true] 채팅방에서 모든 댓글을 찾습니다
async fn find_comment_by_room(
    req: HttpRequest,
    body: web::Json<RoomUrlDto>,
    query: web::Query<RoomQueryString>,
    state: web::Data<AppState>,
) -> impl Responder {
    let url = Comment::remove_query_string(&body.url);
    let comments = match postgres::comment::find_comment_by_room(
        &state.postgres,
        &url,
        query.get_offset(),
        query.get_limit(),
    )
    .await
    {
        Ok(comments) => comments,
        Err(e) => {
            return HttpResponse::InternalServerError().json(JsonMessage {
                msg: format!("Error: {:?}", e),
            })
        }
    };

    if query.get_is_user() == false {
        return HttpResponse::Ok().json(comments);
    }

    let user_uuid = match validate_request(req, &state.postgres).await {
        Ok(uuid) => uuid,
        Err(e) => return e,
    };

    let mut result: Vec<CommentResponse> = vec![];
    // TODO can run asynchronously
    for comment in comments {
        let comment_like = match postgres::comment::find_one_comment_like(
            &state.postgres,
            &user_uuid,
            &comment.uuid,
        )
        .await
        {
            Ok(comment_like) => {
                if comment_like.is_none() {
                    0
                } else {
                    comment_like.unwrap().like
                }
            }
            Err(e) => return HttpResponse::InternalServerError().json(format!("Error: {:?}", e)),
        };

        result.push(CommentResponse::new(comment, comment_like));
    }

    HttpResponse::Ok().json(result)
}

/// [GET /room/comment/best?offset=0&limit=10&is_user=true] 채팅방의 베스트 댓글 찾습니다
async fn find_best_comment_by_room(
    req: HttpRequest,
    body: web::Json<RoomUrlDto>,
    query: web::Query<RoomQueryString>,
    state: web::Data<AppState>,
) -> impl Responder {
    let url = Comment::remove_query_string(&body.url);
    let comments = match postgres::comment::find_best_comment_by_room(
        &state.postgres,
        &url,
        query.get_offset(),
        query.get_limit(),
    )
    .await
    {
        Ok(comments) => comments,
        Err(e) => {
            return HttpResponse::InternalServerError().json(JsonMessage {
                msg: format!("Error: {:?}", e),
            })
        }
    };

    if query.get_is_user() == false {
        return HttpResponse::Ok().json(comments);
    }

    let user_uuid = match validate_request(req, &state.postgres).await {
        Ok(uuid) => uuid,
        Err(e) => return e,
    };

    let mut futures = vec![];
    let mut result: Vec<CommentResponse> = vec![];

    for comment in comments.iter() {
        futures.push(postgres::comment::find_one_comment_like(
            &state.postgres,
            &user_uuid,
            &comment.uuid,
        ));
    }

    let comment_like_list: Vec<i32> = futures::future::join_all(futures)
        .await
        .into_iter()
        .map(|res| match res {
            Ok(comment_like) => {
                if comment_like.is_none() {
                    0
                } else {
                    comment_like.unwrap().like
                }
            }
            Err(_) => 0,
        })
        .collect();

    let mut i = 0;
    for comment in comments {
        result.push(CommentResponse::new(comment, comment_like_list[i]));
        i += 1;
    }

    HttpResponse::Ok().json(result)
}