From efdfbe7229b94027077da5d2bc4320f3e01f4c45 Mon Sep 17 00:00:00 2001
From: mike12345567 <me@michaeldrury.co.uk>
Date: Fri, 20 Sep 2024 17:58:31 +0100
Subject: [PATCH] Fixing an issue that was stopping the limit from being
 applied to MySQL, it needs to wrap the query the same as all other DBs,
 however it needs to apply the where statement in a slightly different manner.

---
 packages/backend-core/src/sql/sql.ts | 55 +++++++++++++++++-----------
 1 file changed, 33 insertions(+), 22 deletions(-)

diff --git a/packages/backend-core/src/sql/sql.ts b/packages/backend-core/src/sql/sql.ts
index 55f71d76b0..a9400b1839 100644
--- a/packages/backend-core/src/sql/sql.ts
+++ b/packages/backend-core/src/sql/sql.ts
@@ -930,7 +930,8 @@ class InternalBuilder {
       }
       const relatedTable = meta.tables?.[toTable]
       const toAlias = aliases?.[toTable] || toTable,
-        fromAlias = aliases?.[fromTable] || fromTable
+        fromAlias = aliases?.[fromTable] || fromTable,
+        throughAlias = (throughTable && aliases?.[throughTable]) || throughTable
       let toTableWithSchema = this.tableNameWithSchema(toTable, {
         alias: toAlias,
         schema: endpoint.schema,
@@ -961,30 +962,38 @@ class InternalBuilder {
         // add sorting to get consistent order
         .orderBy(primaryKey)
 
-      // many-to-many relationship with junction table
-      if (throughTable && toPrimary && fromPrimary) {
-        const throughAlias = aliases?.[throughTable] || throughTable
+      const addCorrelatedWhere = (
+        query: Knex.QueryBuilder,
+        column1: string,
+        column2: string
+      ) => {
+        return query.where(
+          column1,
+          "=",
+          knex.raw(this.quotedIdentifier(column2))
+        )
+      }
+
+      const isManyToMany = throughTable && toPrimary && fromPrimary
+      let correlatedTo = isManyToMany
+          ? `${throughAlias}.${fromKey}`
+          : `${toAlias}.${toKey}`,
+        correlatedFrom = isManyToMany
+          ? `${fromAlias}.${fromPrimary}`
+          : `${fromAlias}.${fromKey}`
+      // many-to-many relationship needs junction table join
+      if (isManyToMany) {
         let throughTableWithSchema = this.tableNameWithSchema(throughTable, {
           alias: throughAlias,
           schema: endpoint.schema,
         })
-        subQuery = subQuery
-          .join(throughTableWithSchema, function () {
-            this.on(`${toAlias}.${toPrimary}`, "=", `${throughAlias}.${toKey}`)
-          })
-          .where(
-            `${throughAlias}.${fromKey}`,
-            "=",
-            knex.raw(this.quotedIdentifier(`${fromAlias}.${fromPrimary}`))
-          )
+        subQuery = subQuery.join(throughTableWithSchema, function () {
+          this.on(`${toAlias}.${toPrimary}`, "=", `${throughAlias}.${toKey}`)
+        })
       }
-      // one-to-many relationship with foreign key
-      else {
-        subQuery = subQuery.where(
-          `${toAlias}.${toKey}`,
-          "=",
-          knex.raw(this.quotedIdentifier(`${fromAlias}.${fromKey}`))
-        )
+      // my-sql needs the where statement to be part of main query, not sub-query
+      if (sqlClient !== SqlClient.MY_SQL) {
+        subQuery = addCorrelatedWhere(subQuery, correlatedTo, correlatedFrom)
       }
 
       const standardWrap = (select: string): Knex.QueryBuilder => {
@@ -1009,8 +1018,10 @@ class InternalBuilder {
           )
           break
         case SqlClient.MY_SQL:
-          wrapperQuery = subQuery.select(
-            knex.raw(`json_arrayagg(json_object(${fieldList}))`)
+          wrapperQuery = addCorrelatedWhere(
+            standardWrap(`json_arrayagg(json_object(${fieldList}))`),
+            isManyToMany ? fromKey! : toKey!,
+            correlatedFrom
           )
           break
         case SqlClient.ORACLE: