fix: various mssql compat fixes

Author: jacek-prisma

.github/workflows/test-query-compiler.yml

@@ -56,6 +56,12 @@ jobs:
             relation_load_strategy: '["query"]'
             test_threads: 1
 
+          - name: mssql
+            setup_task: dev-mssql-qc
+            ignored_tests_list: query-compiler/query-engine-tests-todo/mssql/skip
+            should_fail_tests_list: query-compiler/query-engine-tests-todo/mssql/fail
+            relation_load_strategy: '["query"]'
+
     name: ${{ matrix.adapter.name }}
 
     uses: ./.github/workflows/test-query-compiler-template.yml

Makefile

@@ -376,6 +376,11 @@ start-mssql_edge:
 dev-mssql_edge: start-mssql_edge
 	cp $(CONFIG_PATH)/sqlserver2019 $(CONFIG_FILE)
 
+dev-mssql-qc: start-mssql_2022 build-qc-wasm build-driver-adapters-kit-qc
+	cp $(CONFIG_PATH)/sqlserver-qc $(CONFIG_FILE)
+
+test-mssql-qc: dev-mssql-qc test-qe
+
 start-mssql_2017:
 	docker compose -f docker-compose.yml up --wait -d --remove-orphans mssql-2017
 

libs/driver-adapters/executor/package.json

@@ -27,6 +27,7 @@
     "@prisma/adapter-better-sqlite3": "workspace:*",
     "@prisma/adapter-d1": "workspace:*",
     "@prisma/adapter-libsql": "workspace:*",
+    "@prisma/adapter-mssql": "workspace:*",
     "@prisma/adapter-neon": "workspace:*",
     "@prisma/adapter-pg": "workspace:*",
     "@prisma/adapter-planetscale": "workspace:*",

libs/driver-adapters/executor/src/driver-adapters-manager/mssql.ts

@@ -0,0 +1,59 @@
+import { PrismaMssql } from '@prisma/adapter-mssql'
+import type {
+  SqlDriverAdapter,
+  SqlDriverAdapterFactory,
+} from '@prisma/driver-adapter-utils'
+import type { DriverAdaptersManager, SetupDriverAdaptersInput } from './index'
+import type { DriverAdapterTag, EnvForAdapter } from '../types'
+
+const TAG = 'mssql' as const satisfies DriverAdapterTag
+type TAG = typeof TAG
+
+export class MssqlManager implements DriverAdaptersManager {
+  #factory: SqlDriverAdapterFactory
+  #adapter?: SqlDriverAdapter
+
+  private constructor(
+    private env: EnvForAdapter<TAG>,
+    { url }: SetupDriverAdaptersInput,
+  ) {
+    const config = mssqlOptions(url)
+    this.#factory = new PrismaMssql(config, { schema: config.schema })
+  }
+
+  static async setup(env: EnvForAdapter<TAG>, input: SetupDriverAdaptersInput) {
+    return new MssqlManager(env, input)
+  }
+
+  factory() {
+    return this.#factory
+  }
+
+  async connect() {
+    this.#adapter = await this.#factory.connect()
+    return this.#adapter
+  }
+
+  async teardown() {
+    await this.#adapter?.dispose()
+  }
+}
+
+function mssqlOptions(url: string) {
+  const [, server, port, database, schema, user, password] =
+    url.match(
+      /^sqlserver:\/\/([^:;]+):(\d+);database=([^;]+);schema=([^;]+);user=([^;]+);password=([^;]+);/,
+    ) || []
+
+  return {
+    user,
+    password,
+    database,
+    schema,
+    server,
+    port: Number(port),
+    options: {
+      trustServerCertificate: true,
+    },
+  }
+}

libs/driver-adapters/executor/src/qc-test-worker/worker-query.ts

@@ -10,13 +10,7 @@ import {
   type TransactionManager,
   UserFacingError,
 } from '@prisma/client-engine-runtime'
-import {
-  ColumnType,
-  ColumnTypeEnum,
-  IsolationLevel,
-  SqlQueryable,
-  SqlResultSet,
-} from '@prisma/driver-adapter-utils'
+import { IsolationLevel, SqlQueryable } from '@prisma/driver-adapter-utils'
 import Decimal from 'decimal.js'
 
 import { JsonOutputTaggedValue } from '../engines/JsonProtocol'

libs/driver-adapters/executor/src/setup.ts

@@ -10,6 +10,7 @@ import { LibSQLManager } from './driver-adapters-manager/libsql'
 import { PlanetScaleManager } from './driver-adapters-manager/planetscale'
 import { D1Manager } from './driver-adapters-manager/d1'
 import { BetterSQLite3Manager } from './driver-adapters-manager/better-sqlite3'
+import { MssqlManager } from './driver-adapters-manager/mssql'
 
 export async function setupDriverAdaptersManager(
   env: Env,
@@ -40,5 +41,9 @@ export async function setupDriverAdaptersManager(
       { DRIVER_ADAPTER: 'better-sqlite3' },
       async (env) => await BetterSQLite3Manager.setup(env, input),
     )
+    .with(
+      { DRIVER_ADAPTER: 'mssql' },
+      async (env) => await MssqlManager.setup(env, input),
+    )
     .exhaustive()
 }

libs/driver-adapters/executor/src/types/env.ts

@@ -47,7 +47,13 @@ export const Env = S.extend(
     EnvPlanetScale,
     EnvNeonWS,
     S.struct({
-      DRIVER_ADAPTER: S.literal('pg', 'libsql', 'd1', 'better-sqlite3'),
+      DRIVER_ADAPTER: S.literal(
+        'pg',
+        'libsql',
+        'd1',
+        'better-sqlite3',
+        'mssql',
+      ),
     }),
   ),
   S.union(

libs/driver-adapters/pnpm-workspace.yaml

@@ -2,6 +2,7 @@ packages:
   - '../../../prisma/packages/adapter-d1'
   - '../../../prisma/packages/adapter-better-sqlite3'
   - '../../../prisma/packages/adapter-libsql'
+  - '../../../prisma/packages/adapter-mssql'
   - '../../../prisma/packages/adapter-neon'
   - '../../../prisma/packages/adapter-pg'
   - '../../../prisma/packages/adapter-planetscale'

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

@@ -293,15 +293,28 @@ impl<'a, 'b> NodeTranslator<'a, 'b> {
                     let fields = self.process_edge_selections(edge, &node, selection);
 
                     match sink {
-                        RowSink::AllRows(field) | RowSink::SingleRowArray(field) => {
+                        RowSink::All(field) | RowSink::ExactlyOne(field) | RowSink::AtMostOne(field) => {
                             *field.node_input_field(&mut node) = vec![SelectionResult::new(fields)];
                         }
-                        RowSink::SingleRow(field) => {
+                        RowSink::Single(field) => {
                             *field.node_input_field(&mut node) = SelectionResult::new(fields);
                         }
-                        RowSink::SingleRowFilter(field) => {
+                        RowSink::ExactlyOneFilter(field) => {
                             *field.node_input_field(&mut node) = SelectionResult::new(fields).filter();
                         }
+                        RowSink::ExactlyOneWriteArgs(selection, field) => {
+                            let result = SelectionResult::new(fields);
+                            let model = node.as_query().map(Query::model);
+                            let args = field.node_input_field(&mut node);
+                            for arg in args {
+                                arg.inject(selection.assimilate(result.clone()).map_err(|err| {
+                                    TranslateError::GraphBuildError(QueryGraphBuilderError::DomainError(err))
+                                })?);
+                                if let Some(model) = &model {
+                                    arg.update_datetimes(model);
+                                }
+                            }
+                        }
                         RowSink::Discard => {}
                     }
                 }
@@ -432,11 +445,8 @@ impl<'a, 'b> NodeTranslator<'a, 'b> {
 
                 let requires_unique = matches!(
                     edge_content,
-                    Some(QueryGraphDependency::ProjectedDataSinkDependency(
-                        _,
-                        RowSink::SingleRow(_) | RowSink::SingleRowArray(_) | RowSink::SingleRowFilter(_),
-                        _
-                    ))
+                    Some(QueryGraphDependency::ProjectedDataSinkDependency(_, sink, _))
+                        if sink.is_unique()
                 );
 
                 let source = self.graph.edge_source(&edge);

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

@@ -44,6 +44,11 @@ pub(crate) fn translate_read_query(query: ReadQuery, builder: &dyn QueryBuilder)
         }
 
         ReadQuery::ManyRecordsQuery(mut mrq) => {
+            // Skip the query entirely if the take is 0.
+            if mrq.args.take == Take::Some(0) {
+                return Ok(Expression::Concat(vec![]));
+            }
+
             let selected_fields = match mrq.relation_load_strategy {
                 RelationLoadStrategy::Join => mrq.selected_fields.into_virtuals_last(),
                 RelationLoadStrategy::Query => mrq.selected_fields.without_relations().into_virtuals_last(),
@@ -220,6 +225,11 @@ fn build_read_related_records(
     links: Vec<ConditionalLink>,
     builder: &dyn QueryBuilder,
 ) -> TranslateResult<(Expression, JoinMetadata)> {
+    // Skip the query entirely if the take is 0.
+    if rrq.args.take == Take::Some(0) {
+        return Ok((Expression::Concat(vec![]), JoinMetadata::default()));
+    }
+
     let mut linkage = RelationLinkage::new(rrq.parent_field.clone(), links);
 
     if let Some(results) = rrq.parent_results {
@@ -386,7 +396,7 @@ fn extract_distinct_by(args: &mut QueryArguments) -> Vec<String> {
     distinct.db_names().collect_vec()
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Default, Clone)]
 struct JoinMetadata {
     fields: Vec<String>,
     is_relation_unique: bool,