feat: generate m2m connects and disconnects in the compiler

quaint/src/ast/expression.rs

@@ -377,7 +377,8 @@ impl<'a> Comparable<'a> for Expression<'a> {
     where
         T: Into<Expression<'a>>,
     {
-        Compare::In(Box::new(self), Box::new(selection.into()))
+        let expr = extract_single_var_row(selection.into());
+        Compare::In(Box::new(self), Box::new(expr))
     }
 
     fn not_in_selection<T>(self, selection: T) -> Compare<'a>
@@ -521,3 +522,37 @@ impl<'a> Comparable<'a> for Expression<'a> {
         Compare::All(Box::new(self))
     }
 }
+
+/// Converts a row consisting of a single var into the var itself.
+/// Any other expression is returned as is.
+fn extract_single_var_row(expr: Expression) -> Expression {
+    let Expression {
+        kind: ExpressionKind::Row(values),
+        ..
+    } = &expr
+    else {
+        return expr;
+    };
+
+    let Some((
+        val @ Expression {
+            kind:
+                ExpressionKind::Parameterized(Value {
+                    typed: ValueType::Var(_, _),
+                    ..
+                }),
+            ..
+        },
+        [],
+    )) = values.values.split_first()
+    else {
+        return expr;
+    };
+
+    val.clone()
+        .decorate(
+            Some("prisma-comma-repeatable-start"),
+            Some("prisma-comma-repeatable-end"),
+        )
+        .into()
+}

quaint/src/ast/row.rs

@@ -162,6 +162,19 @@ where
     }
 }
 
+impl<'a, A> FromIterator<A> for Row<'a>
+where
+    A: Into<Expression<'a>>,
+{
+    fn from_iter<T>(iter: T) -> Self
+    where
+        T: IntoIterator<Item = A>,
+    {
+        let inner = iter.into_iter().map(Into::into).collect::<Vec<_>>();
+        Self { values: inner }
+    }
+}
+
 impl<'a> Comparable<'a> for Row<'a> {
     fn equals<T>(self, comparison: T) -> Compare<'a>
     where

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

@@ -207,23 +207,17 @@ fn build_read_one2m_query(
     selected_fields: &FieldSelection,
     builder: &dyn QueryBuilder,
 ) -> TranslateResult<(Expression, JoinFields)> {
-    let join_fields = field
-        .related_field()
-        .left_scalars()
-        .into_iter()
-        .map(|sf| sf.name().to_owned())
-        .collect();
+    let related_scalars = field.related_field().left_scalars();
+    let join_fields = related_scalars.iter().map(|sf| sf.name().to_owned()).collect();
 
     // TODO: we ignore chunking for now
-    let linking_scalars = field.related_field().left_scalars();
-
     if let Some(conditions) = conditions {
         assert_eq!(
-            linking_scalars.len(),
+            related_scalars.len(),
             conditions.len(),
             "linking fields should match conditions"
         );
-        for (condition, child_field) in conditions.into_iter().zip(linking_scalars) {
+        for (condition, child_field) in conditions.into_iter().zip(related_scalars) {
             args.add_filter(Filter::Scalar(ScalarFilter {
                 condition,
                 projection: ScalarProjection::Single(child_field.clone()),

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

@@ -18,9 +18,8 @@ pub mod write;
 use std::{collections::HashMap, marker::PhantomData};
 
 use quaint::{
-    ast::{Column, Comparable, ConditionTree, Conjunctive, Decoratable, Delete, Query, Row, Values},
+    ast::{Column, Comparable, ConditionTree, Query, Row, Values},
     visitor::Visitor,
-    Value, ValueType,
 };
 use query_builder::{DbQuery, QueryBuilder};
 use query_structure::{
@@ -219,37 +218,7 @@ impl<'a, V: Visitor<'a>> QueryBuilder for SqlQueryBuilder<'a, V> {
         parent_id: &SelectionResult,
         child_ids: &[SelectionResult],
     ) -> Result<DbQuery, Box<dyn std::error::Error + Send + Sync>> {
-        let relation = field.relation();
-
-        let parent_column = field.related_field().m2m_column(&self.context);
-        let child_column = field.m2m_column(&self.context);
-
-        let parent_id_values = parent_id.db_values(&self.context);
-        let parent_id_criteria = parent_column.equals(parent_id_values);
-
-        let values = child_ids
-            .iter()
-            .map(|id| id.db_values(&self.context))
-            .collect::<Vec<_>>();
-
-        let child_id_criteria = match values.split_first().map(|(fst, rem)| (&fst[..], rem)) {
-            Some((
-                [val @ Value {
-                    typed: ValueType::Var(_, _),
-                    ..
-                }],
-                [],
-            )) => child_column.in_selection(val.clone().decorate(
-                Some("prisma-comma-repeatable-start"),
-                Some("prisma-comma-repeatable-end"),
-            )),
-            _ => child_column.in_selection(values),
-        };
-
-        let query = Delete::from_table(relation.as_table(&self.context))
-            .so_that(parent_id_criteria.and(child_id_criteria))
-            .add_traceparent(self.context.traceparent);
-
+        let query = write::delete_relation_table_records(&field, parent_id, child_ids, &self.context);
         self.convert_query(query)
     }
 

query-engine/query-builders/sql-query-builder/src/write.rs

@@ -314,7 +314,8 @@ pub fn delete_relation_table_records(
     let parent_id_values = parent_id.db_values(ctx);
     let parent_id_criteria = parent_column.equals(parent_id_values);
 
-    let child_id_criteria = super::in_conditions(&[child_column], child_ids, ctx);
+    let child_ids = child_ids.iter().flat_map(|id| id.db_values(ctx)).collect::<Row>();
+    let child_id_criteria = child_column.in_selection(child_ids);
 
     Delete::from_table(relation.as_table(ctx))
         .so_that(parent_id_criteria.and(child_id_criteria))