fix: fix truncated postgres aliases (#5704)

[TML-1525](https://linear.app/prisma-company/issue/TML-1525/many-to-many-relations-quietly-fail-to-load-when-model-names-are-too)

Fixes prisma/prisma#28304

Author: jacek-prisma

libs/driver-adapters/executor/src/query-compiler.ts

@@ -21,9 +21,8 @@ export async function initQueryCompiler(
   params: QueryCompilerParams,
   connector: Env['CONNECTOR'],
 ): Promise<QueryCompiler> {
-  const { getQueryCompilerForConnector } = await import(
-    './query-compiler-wasm.js'
-  )
+  const { getQueryCompilerForConnector } =
+    await import('./query-compiler-wasm.js')
   const WasmQueryCompiler = (await getQueryCompilerForConnector(
     connector,
   )) as QueryCompiler

libs/driver-adapters/pnpm-workspace.yaml

@@ -12,6 +12,8 @@ packages:
   - '../../../prisma/packages/client-runtime-utils'
   - '../../../prisma/packages/debug'
   - '../../../prisma/packages/driver-adapter-utils'
+  - '../../../prisma/packages/sqlcommenter'
+  - '../../../prisma/packages/json-protocol'
   - './executor'
 
 onlyBuiltDependencies:

query-compiler/query-builders/query-builder/src/lib.rs

@@ -28,7 +28,7 @@ pub trait QueryBuilder {
         linkage: RelationLinkage,
         query_arguments: QueryArguments,
         selected_fields: &FieldSelection,
-    ) -> Result<DbQuery, Box<dyn std::error::Error + Send + Sync>>;
+    ) -> Result<GetRelatedRecordsQuery, Box<dyn std::error::Error + Send + Sync>>;
 
     fn build_aggregate(
         &self,
@@ -141,6 +141,15 @@ pub struct CreateRecordDefaultsQuery {
     pub field_placeholders: Vec<(ScalarField, Placeholder)>,
 }
 
+/// A query that retrieves related records through an M2M relation.
+#[cfg(feature = "relation_joins")]
+pub struct GetRelatedRecordsQuery {
+    /// The query that retrieves the related records.
+    pub query: DbQuery,
+    /// The alias used for the linking field in the query.
+    pub linking_field_alias: String,
+}
+
 #[derive(Debug)]
 pub struct ConditionalLink {
     field: ScalarField,

query-compiler/query-builders/sql-query-builder/src/lib.rs

@@ -16,7 +16,7 @@ pub mod update;
 pub mod value;
 pub mod write;
 
-use std::{collections::HashMap, iter, marker::PhantomData};
+use std::{collections::HashMap, iter, marker::PhantomData, sync::atomic::AtomicUsize};
 
 use itertools::{Either, Itertools};
 use model_extensions::ScalarFieldExt;
@@ -28,6 +28,8 @@ use quaint::{
     },
     visitor::Visitor,
 };
+#[cfg(feature = "relation_joins")]
+use query_builder::GetRelatedRecordsQuery;
 use query_builder::{Chunkable, CreateRecord, CreateRecordDefaultsQuery, DbQuery, QueryBuilder};
 use query_structure::{
     AggregationSelection, DatasourceFieldName, FieldSelection, Filter, Model, ModelProjection, QueryArguments,
@@ -43,20 +45,24 @@ pub use sql_trace::SqlTraceComment;
 use value::GeneratorCall;
 
 const PARAMETER_LIMIT: usize = 2000;
+// The smallest identifier length limit among our primary databases (PostgreSQL, MySQL, SQLite).
+const IDENTIFIER_LENGTH_LIMIT: usize = 63;
 
 // The number of parameters that are used for take and limit in a query.
 const TAKE_AND_LIMIT_PARAM_COUNT: usize = 2;
 
 pub struct SqlQueryBuilder<'a, Visitor> {
     context: Context<'a>,
     phantom: PhantomData<fn(Visitor)>,
+    linking_field_alias_counter: AtomicUsize,
 }
 
 impl<'a, V> SqlQueryBuilder<'a, V> {
     pub fn new(context: Context<'a>) -> Self {
         Self {
             context,
             phantom: PhantomData,
+            linking_field_alias_counter: AtomicUsize::new(0),
         }
     }
 
@@ -89,6 +95,18 @@ impl<'a, V> SqlQueryBuilder<'a, V> {
             chunkable,
         })
     }
+
+    fn generate_linking_field_alias(&self, linkage: &query_builder::RelationLinkage) -> String {
+        let full_name = linkage.to_string();
+        // use full name if it fits within the limit
+        if full_name.len() <= IDENTIFIER_LENGTH_LIMIT {
+            return full_name;
+        }
+        let index = self
+            .linking_field_alias_counter
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        format!("@link${index}")
+    }
 }
 
 impl<'a, V: Visitor<'a>> QueryBuilder for SqlQueryBuilder<'a, V> {
@@ -153,7 +171,7 @@ impl<'a, V: Visitor<'a>> QueryBuilder for SqlQueryBuilder<'a, V> {
         linkage: query_builder::RelationLinkage,
         query_arguments: QueryArguments,
         selected_fields: &FieldSelection,
-    ) -> Result<DbQuery, Box<dyn std::error::Error + Send + Sync>> {
+    ) -> Result<GetRelatedRecordsQuery, Box<dyn std::error::Error + Send + Sync>> {
         use std::slice;
 
         use crate::read::SelectDefinition;
@@ -163,7 +181,7 @@ impl<'a, V: Visitor<'a>> QueryBuilder for SqlQueryBuilder<'a, V> {
         use select::JoinConditionExt;
 
         let chunkable = Chunkable::from(&query_arguments);
-        let link_alias = linkage.to_string();
+        let linking_field_alias = self.generate_linking_field_alias(&linkage);
         let (rf, conditions_per_field) = linkage.into_parent_field_and_conditions();
 
         let m2m_alias = self.context.next_table_alias();
@@ -197,7 +215,7 @@ impl<'a, V: Visitor<'a>> QueryBuilder for SqlQueryBuilder<'a, V> {
             .map(|col| col.table(rf.related_model().as_table(&self.context)))
             // Add an m2m column with an alias to make it possible to join it outside of this
             // function.
-            .chain([m2m_col.alias(link_alias)]);
+            .chain([m2m_col.alias(linking_field_alias.clone())]);
 
         let join_condition = rf.m2m_join_conditions(Some(m2m_alias), None, &self.context);
 
@@ -213,7 +231,11 @@ impl<'a, V: Visitor<'a>> QueryBuilder for SqlQueryBuilder<'a, V> {
             .into_iter()
             .fold(select, |acc, val| acc.value(val));
 
-        self.convert_query(select, chunkable)
+        let query = self.convert_query(select, chunkable)?;
+        Ok(GetRelatedRecordsQuery {
+            query,
+            linking_field_alias,
+        })
     }
 
     fn build_aggregate(

query-compiler/query-compiler/src/translate/query/read.rs

@@ -282,16 +282,14 @@ fn build_read_m2m_query(
     selected_fields: &FieldSelection,
     builder: &dyn QueryBuilder,
 ) -> TranslateResult<(Expression, JoinMetadata)> {
-    let link_name = linkage.to_string();
-
-    let query = builder
+    let result = builder
         .build_get_related_records(linkage, args, selected_fields)
         .map_err(TranslateError::QueryBuildFailure)?;
 
     Ok((
-        Expression::Query(query),
+        Expression::Query(result.query),
         JoinMetadata {
-            fields: vec![link_name],
+            fields: vec![result.linking_field_alias],
             is_relation_unique: false,
         },
     ))

query-engine/connector-test-kit-rs/query-engine-tests/tests/queries/simple/m2m.rs

@@ -227,7 +227,7 @@ mod m2m {
         insta::assert_snapshot!(
           run_query!(&runner, r#"{
                 findUniqueItem(relationLoadStrategy: join, where: { id: 1 })
-                { id categories { id } } 
+                { id categories { id } }
             }"#),
           @r###"{"data":{"findUniqueItem":null}}"###
         );
@@ -243,6 +243,46 @@ mod m2m {
         Ok(())
     }
 
+    fn schema_28304() -> String {
+        let schema = indoc! {
+            r#"model AReallyLongModelName {
+              id Int @id @default(autoincrement())
+
+              verys AVeryVeryLongModelName[]
+            }
+
+            model AVeryVeryLongModelName {
+              id Int @id @default(autoincrement())
+
+              reallys AReallyLongModelName[]
+            }"#
+        };
+
+        schema.to_owned()
+    }
+
+    // ! (https://github.com/prisma/prisma/issues/28304) - Many-to-many alias character limit
+    #[connector_test(schema(schema_28304), only(Postgres))]
+    async fn repro_28304(runner: Runner) -> TestResult<()> {
+        run_query!(
+            &runner,
+            r#"mutation { createOneAReallyLongModelName(data: { verys: { create: {} } }) { id } }"#
+        );
+
+        insta::assert_snapshot!(
+          run_query!(&runner, r#"{
+                findFirstAReallyLongModelName(relationLoadStrategy: query) {
+                    id
+                    verys {
+                        id
+                    }
+                }
+            }"#),
+          @r###"{"data":{"findFirstAReallyLongModelName":{"id":1,"verys":[{"id":1}]}}}"###
+        );
+        Ok(())
+    }
+
     async fn test_data(runner: &Runner) -> TestResult<()> {
         runner
             .query(