perf: improve to-one relational filters #4235

Weakky · 2023-09-13T14:00:00Z

Overview

fixes prisma/prisma#14688
fixes prisma/prisma#17879
fixes prisma/prisma#7894

Refactor the filter builder to use the visitor pattern & splitted everything into smaller modules
Use LEFT JOINs when traversing to-one relations. Note: when rendering joins for mutations, we always need at least one sub-select before we can render nested joins.
Even though it's not directly part of this PR, it also integrates the improvements from Remove unnecessary join in RelationFilter #3882, which will be part of the benchmarks down below.
Caveats: Joins are not deduplicated, even within a same filter. So we do not fix Optimisation: Combine where directives on related records prisma#15417

SQL differences

Consider this schema:

model User {
  id   Int     @id @default(autoincrement())
  name String?

  posts Post[]
}

model Post {
  id    Int     @id @default(autoincrement())
  title String?

  userId Int?
  user   User? @relation(fields: [userId], references: [id])

  comments Comment[]
}

model Comment {
  id   Int     @id @default(autoincrement())
  body String?

  postId Int?
  post   Post? @relation(fields: [postId], references: [id])
}

to-one -> to-one

{
  findManyComment(where: { post: { is: { author: { is: { name: "John" } } } } }) {
    id
  }
}

Before 👇

SELECT
  "Comment"."id"
FROM
  "Comment"
WHERE
  ("Comment"."id") IN (
    SELECT
      "t0"."id"
    FROM
      "Comment" AS "t0"
      INNER JOIN "Post" AS "j0" ON ("j0"."id") = ("t0"."postId")
    WHERE
      (
        ("j0"."id") IN (
          SELECT
            "t1"."id"
          FROM
            "Post" AS "t1"
            INNER JOIN "User" AS "j1" ON ("j1"."id") = ("t1"."userId")
          WHERE
            (
              "j1"."name" = $ 1
              AND "t1"."id" IS NOT NULL
            )
        )
        AND "t0"."id" IS NOT NULL
      )
  );

After 👇

SELECT
  "Comment"."id"
FROM
  "Comment"
  LEFT JOIN "Post" AS "j1" ON ("j1"."id") = ("Comment"."postId")
  LEFT JOIN "User" AS "j2" ON ("j2"."id") = ("j1"."userId")
WHERE
  (
    "j2"."name" = $ 1
    AND ("j2"."id" IS NOT NULL)
    AND ("j1"."id" IS NOT NULL)
  );

some -> to-one (inlined)

{
  findManyUser(where: { posts: { some: { author: { is: { name: "John" } } } } }) {
    id
  }
}

Before 👇

SELECT
  "User"."id"
FROM
  "User"
WHERE
  ("User"."id") IN (
    SELECT
      "t0"."id"
    FROM
      "User" AS "t0"
      INNER JOIN "Post" AS "j0" ON ("j0"."userId") = ("t0"."id")
    WHERE
      (
        ("j0"."id") IN (
          SELECT
            "t1"."id"
          FROM
            "Post" AS "t1"
            INNER JOIN "User" AS "j1" ON ("j1"."id") = ("t1"."userId")
          WHERE
            (
              "j1"."name" = $1
              AND "t1"."id" IS NOT NULL
            )
        )
        AND "t0"."id" IS NOT NULL
      )
  );

After 👇

SELECT
  "User"."id"
FROM
  "User"
WHERE
  ("User"."id") IN (
    SELECT
      "t1"."userId"
    FROM
      "Post" AS "t1"
      LEFT JOIN "User" AS "j2" ON ("j2"."id") = ("t1"."userId")
    WHERE
      (
        "j2"."name" = $ 1
        AND ("j2"."id" IS NOT NULL)
        AND "t1"."userId" IS NOT NULL
      )
  );

some -> every -> to-one (inlined)

{
  findManyUser(
    where: {
      posts: {
        some: { comments: { every: { post: { is: { title: "Hello" } } } } }
      }
    }
  ) {
    id
  }
}

Before 👇

SELECT
  "User"."id"
FROM
  "User"
WHERE
  ("User"."id") IN (
    SELECT
      "t0"."id"
    FROM
      "User" AS "t0"
      INNER JOIN "Post" AS "j0" ON ("j0"."userId") = ("t0"."id")
    WHERE
      (
        ("j0"."id") NOT IN (
          SELECT
            "t1"."id"
          FROM
            "Post" AS "t1"
            INNER JOIN "Comment" AS "j1" ON ("j1"."postId") = ("t1"."id")
          WHERE
            (
              (
                NOT ("j1"."id") IN (
                  SELECT
                    "t2"."id"
                  FROM
                    "Comment" AS "t2"
                    INNER JOIN "Post" AS "j2" ON ("j2"."id") = ("t2"."postId")
                  WHERE
                    (
                      "j2"."title" = $ 1
                      AND "t2"."id" IS NOT NULL
                    )
                )
              )
              AND "t1"."id" IS NOT NULL
            )
        )
        AND "t0"."id" IS NOT NULL
      )
  );

After 👇

SELECT
  "User"."id"
FROM
  "User"
WHERE
  ("User"."id") IN (
    SELECT
      "t1"."userId"
    FROM
      "Post" AS "t1"
    WHERE
      (
        ("t1"."id") NOT IN (
          SELECT
            "t2"."postId"
          FROM
            "Comment" AS "t2"
            LEFT JOIN "Post" AS "j3" ON ("j3"."id") = ("t2"."postId")
          WHERE
            (
              (
                NOT (
                  "j3"."title" = $1
                  AND ("j3"."id" IS NOT NULL)
                )
              )
              AND "t2"."postId" IS NOT NULL
            )
        )
        AND "t1"."userId" IS NOT NULL
      )
  );

Benchmarks

(source)

cpu: Apple M1 Max
runtime: node v18.17.1 (arm64-darwin)

benchmark      time (avg)             (min … max)       p75       p99      p995
------------------------------------------------- -----------------------------
• prisma.movie.findMany({ where: { reviews: { author: { ... } }, take: 100 }) (to-many -> to-one)
------------------------------------------------- -----------------------------
Prisma V4  572.87 ms/iter (524.49 ms … 647.22 ms) 585.46 ms 647.22 ms 647.22 ms
Prisma V5  314.03 ms/iter (283.22 ms … 381.27 ms) 323.18 ms 381.27 ms 381.27 ms

summary for prisma.movie.findMany({ where: { reviews: { author: { ... } }, take: 100 }) (to-many -> to-one)
  Prisma V5
   1.82x faster than Prisma V4

• prisma.movie.findMany({ where: { cast: { person: { ... } }, take: 100 }) (m2m -> to-one)
------------------------------------------------- -----------------------------
Prisma V4    6.75 ms/iter    (3.36 ms … 13.96 ms)   7.87 ms  13.96 ms  13.96 ms
Prisma V5    4.92 ms/iter    (2.88 ms … 12.05 ms)   5.75 ms   9.77 ms  12.05 ms

summary for prisma.movie.findMany({ where: { cast: { person: { ... } }, take: 100 }) (m2m -> to-one)
  Prisma V5
   1.37x faster than Prisma V4

• prisma.review.findMany({ where: { author: { ... } }, take: 100 }) (to-one)
------------------------------------------------- -----------------------------
Prisma V4     1.91 s/iter       (1.82 s … 2.05 s)    2.01 s    2.05 s    2.05 s
Prisma V5    5.03 ms/iter    (2.61 ms … 11.14 ms)   6.15 ms   9.43 ms  11.14 ms

summary for prisma.review.findMany({ where: { author: { ... } }, take: 100 }) (to-one)
  Prisma V5
   379.24x faster than Prisma V4

• prisma.actor.findMany({ where: { movies: { some: { reviews: { some: { author: { ... } } } } } }, take: 20 } (to-many -> to-many -> to-one)
------------------------------------------------- -----------------------------
Prisma V4  506.46 ms/iter (444.91 ms … 593.76 ms) 529.23 ms 593.76 ms 593.76 ms
Prisma V5   268.7 ms/iter (208.79 ms … 300.38 ms) 286.87 ms 300.38 ms 300.38 ms

summary for prisma.actor.findMany({ where: { movies: { some: { reviews: { some: { author: { ... } } } } } }, take: 20 } (to-many -> to-many -> to-one)
  Prisma V5
   1.88x faster than Prisma V4

codspeed-hq · 2023-09-13T14:25:25Z

CodSpeed Performance Report

Merging #4235 will not alter performance

_{Comparing perf/relational-filters-to-one-joins (8a4bf6b) with main (818b9fc)}

Summary

✅ 11 untouched benchmarks

Weakky · 2023-09-15T10:30:26Z

quaint/src/ast/select.rs

@@ -453,6 +453,14 @@ impl<'a> Select<'a> {
        self
    }

+    pub fn join<J>(mut self, join: J) -> Self


add documentation

Weakky · 2023-09-15T10:30:33Z

quaint/src/ast/table.rs

@@ -344,6 +344,20 @@ impl<'a> Table<'a> {

        self
    }
+
+    pub fn join<J>(self, join: J) -> Self


add documentation

Weakky · 2023-09-15T10:30:52Z

.../connector-test-kit-rs/query-engine-tests/tests/queries/filters/extended_relation_filters.rs

        insta::assert_snapshot!(
-          run_query!(&runner, r#"{ findManyAlbum(where: { Tracks: { some: { OR:[{ MediaType: {is: { Name: { equals: "MediaType1" }}}}, { Genre: { is: { Name: { equals: "Genre2" }}}}]}}}) { Title }}"#),
+          run_query!(&runner, r#"{ findManyAlbum(where: { Tracks: { some: { OR:[{ MediaType: {is: { Name: { equals: "MediaType1" }}}}, { Genre: { is: { Name: { equals: "Genre2" }}}}]}}}, orderBy: { Title: asc }) { Title }}"#),
          @r###"{"data":{"findManyAlbum":[{"Title":"Album1"},{"Title":"Album3"},{"Title":"Album4"},{"Title":"Album5"}]}}"###
        );


The ordering is needed because joins messes up the natural order

Weakky · 2023-09-15T10:30:59Z

.../connector-test-kit-rs/query-engine-tests/tests/queries/filters/extended_relation_filters.rs

        insta::assert_snapshot!(
-          run_query!(&runner, r#"{ findManyGenre(where: { Tracks: { some: {} }}) { Name }}"#),
+          run_query!(&runner, r#"{ findManyGenre(where: { Tracks: { some: {} }}, orderBy: { Name: asc }) { Name }}"#),
          @r###"{"data":{"findManyGenre":[{"Name":"Genre1"},{"Name":"Genre2"},{"Name":"Genre3"}]}}"###
        );


The ordering is needed because joins messes up the natural order

Weakky · 2023-09-15T10:31:29Z

query-engine/connectors/sql-query-connector/src/database/operations/update.rs

@@ -31,8 +31,9 @@ pub(crate) async fn update_one_with_selection(
        return get_single_record(conn, model, &filter, &selected_fields, &[], ctx).await;
    }

-    let update = build_update_and_set_query(model, args, Some(&selected_fields), ctx)
-        .so_that(build_update_one_filter(record_filter).aliased_condition_from(None, false, ctx));
+    let cond = FilterBuilder::without_top_level_joins().visit_filter(build_update_one_filter(record_filter), ctx);


Like for all mutations, we don't render filters with top-level joins because we can't.

Weakky · 2023-09-15T10:31:55Z

query-engine/connectors/sql-query-connector/src/filter/alias.rs

This is all copy & pasted stuff that comes with the filter refactoring. So no changes in this file.

Weakky · 2023-09-15T10:33:44Z

query-engine/connectors/sql-query-connector/src/join_utils.rs

+    field: &RelationFieldRef,
+    alias: &str,
+    parent_alias: Option<&str>,
    ctx: &Context<'_>,
 ) -> AliasedJoin {
-    let (left_fields, right_fields) = if rf.is_inlined_on_enclosing_model() {
-        (rf.scalar_fields(), rf.referenced_fields())
-    } else {
-        (
-            rf.related_field().referenced_fields(),
-            rf.related_field().scalar_fields(),
-        )
-    };
-
-    let right_table_alias = format!("{}_{}", join_prefix, rf.related_model().name());
-
-    let related_model = rf.related_model();
-    let pairs = left_fields.into_iter().zip(right_fields);
-
-    let on_conditions: Vec<Expression> = pairs
-        .map(|(a, b)| {
-            let a_col = match previous_join {
-                Some(prev_join) => Column::from((prev_join.alias.to_owned(), a.db_name().to_owned())),
-                None => a.as_column(ctx),
-            };
+    let join_columns: Vec<Column> = field
+        .join_columns(ctx)
+        .map(|c| c.opt_table(parent_alias.map(ToOwned::to_owned)))
+        .collect();

-            let b_col = Column::from((right_table_alias.clone(), b.db_name().to_owned()));
+    let related_table = field.related_model().as_table(ctx);
+    let related_join_columns: Vec<_> = ModelProjection::from(field.related_field().linking_fields())
+        .as_columns(ctx)
+        .map(|col| col.table(alias.to_owned()))
+        .collect();

-            a_col.equals(b_col).into()
-        })
-        .collect::<Vec<_>>();
+    let join = related_table
+        .alias(alias.to_owned())
+        .on(Row::from(related_join_columns).equals(Row::from(join_columns)));

    AliasedJoin {
-        alias: right_table_alias.to_owned(),
-        data: related_model
-            .as_table(ctx)
-            .alias(right_table_alias)
-            .on(ConditionTree::And(on_conditions)),
+        alias: alias.to_owned(),
+        data: Join::Left(join),


Most of the refactorings of this function is just a nicest way to express the same thing.

Weakky · 2023-09-15T10:35:08Z