fix(qe): Add comparison for decimal <-> str (#4784)

* Add comparison for decimal <-> str
add test for batching unquoted decimals

* Moved compact_batch -> q-e-tests/utils
assert 5952 is compacted

---------

Co-authored-by: Serhii Tatarintsev <tatarintsev@prisma.io>

query-engine/connector-test-kit-rs/query-engine-tests/src/utils/batch.rs

@@ -0,0 +1,30 @@
+use query_tests_setup::{
+    query_core::{BatchDocument, QueryDocument},
+    GraphqlBody, MultiQuery, Runner, TestResult,
+};
+
+use crate::run_query;
+
+pub async fn compact_batch(runner: &Runner, queries: Vec<String>) -> TestResult<BatchDocument> {
+    // Ensure individual queries are valid. Helps to debug tests when writing them.
+    for q in queries.iter() {
+        run_query!(runner, q.to_string());
+    }
+
+    // Ensure batched queries are valid
+    runner.batch(queries.clone(), false, None).await?.assert_success();
+
+    let doc = GraphqlBody::Multi(MultiQuery::new(
+        queries.into_iter().map(Into::into).collect(),
+        false,
+        None,
+    ))
+    .into_doc()
+    .unwrap();
+    let batch = match doc {
+        QueryDocument::Multi(batch) => batch.compact(runner.query_schema()),
+        _ => unreachable!(),
+    };
+
+    Ok(batch.compact(runner.query_schema()))
+}

query-engine/connector-test-kit-rs/query-engine-tests/src/utils/mod.rs

@@ -1,10 +1,12 @@
+mod batch;
 mod bytes;
 mod json;
 mod querying;
 mod raw;
 mod string;
 mod time;
 
+pub use batch::*;
 pub use bytes::*;
 pub use raw::*;
 pub use string::*;

query-engine/connector-test-kit-rs/query-engine-tests/tests/new/regressions/prisma_5952.rs

@@ -43,6 +43,48 @@ mod regression {
             r#"query {findUniqueArtist(where:{firstName_netWorth:{firstName:"George",netWorth:"-0.23660010012409"}}) {firstName netWorth}}"#.to_string(),
         ];
 
+        let doc = compact_batch(&runner, queries.clone()).await?;
+        assert!(doc.is_compact());
+
+        let batch_results = runner.batch(queries, false, None).await?;
+        insta::assert_snapshot!(
+            batch_results.to_string(),
+            @r###"{"batchResult":[{"data":{"findUniqueArtist":{"firstName":"Michael","netWorth":"236600000.12409"}}},{"data":{"findUniqueArtist":{"firstName":"George","netWorth":"-0.23660010012409"}}}]}"###
+        );
+
+        Ok(())
+    }
+
+    #[connector_test]
+    async fn decimal_find_different_uniques_unquoted(runner: Runner) -> TestResult<()> {
+        runner
+            .query(indoc! {
+                r#"mutation {createOneArtist(data:{
+                    firstName: "Michael"
+                    netWorth: 236600000.12409
+                }){ firstName }}"#
+            })
+            .await?
+            .assert_success();
+
+        runner
+            .query(indoc! {
+                r#"mutation {createOneArtist(data:{
+                    firstName: "George"
+                    netWorth: -0.23660010012409
+                }){ firstName }}"#
+            })
+            .await?
+            .assert_success();
+
+        let queries = vec![
+            r#"query {findUniqueArtist(where:{firstName_netWorth:{firstName:"Michael",netWorth:236600000.12409}}) {firstName netWorth}}"#.to_string(),
+            r#"query {findUniqueArtist(where:{firstName_netWorth:{firstName:"George",netWorth:-0.23660010012409}}) {firstName netWorth}}"#.to_string(),
+        ];
+
+        let doc = compact_batch(&runner, queries.clone()).await?;
+        assert!(doc.is_compact());
+
         let batch_results = runner.batch(queries, false, None).await?;
         insta::assert_snapshot!(
             batch_results.to_string(),

query-engine/connector-test-kit-rs/query-engine-tests/tests/queries/batching/select_one_compound.rs

@@ -3,7 +3,6 @@ use query_engine_tests::*;
 #[test_suite(schema(schema), capabilities(AnyId))]
 mod compound_batch {
     use indoc::indoc;
-    use query_engine_tests::query_core::{BatchDocument, QueryDocument};
 
     fn schema() -> String {
         let schema = indoc! {
@@ -384,30 +383,6 @@ mod compound_batch {
         Ok(())
     }
 
-    async fn compact_batch(runner: &Runner, queries: Vec<String>) -> TestResult<BatchDocument> {
-        // Ensure individual queries are valid. Helps to debug tests when writing them.
-        for q in queries.iter() {
-            run_query!(runner, q.to_string());
-        }
-
-        // Ensure batched queries are valid
-        runner.batch(queries.clone(), false, None).await?.assert_success();
-
-        let doc = GraphqlBody::Multi(MultiQuery::new(
-            queries.into_iter().map(Into::into).collect(),
-            false,
-            None,
-        ))
-        .into_doc()
-        .unwrap();
-        let batch = match doc {
-            QueryDocument::Multi(batch) => batch.compact(runner.query_schema()),
-            _ => unreachable!(),
-        };
-
-        Ok(batch.compact(runner.query_schema()))
-    }
-
     async fn create_test_data(runner: &Runner) -> TestResult<()> {
         runner
             .query(r#"mutation { createOneArtist(data: { firstName: "Musti" lastName: "Naukio", non_unique: 0 }) { firstName }}"#)

query-engine/request-handlers/src/handler.rs

@@ -1,5 +1,6 @@
 use super::GQLResponse;
 use crate::{GQLError, PrismaResponse, RequestBody};
+use bigdecimal::BigDecimal;
 use futures::FutureExt;
 use indexmap::IndexMap;
 use query_core::{
@@ -11,7 +12,7 @@ use query_core::{
     QueryDocument, QueryExecutor, TxId,
 };
 use query_structure::{parse_datetime, stringify_datetime, PrismaValue};
-use std::{collections::HashMap, fmt, panic::AssertUnwindSafe};
+use std::{collections::HashMap, fmt, panic::AssertUnwindSafe, str::FromStr};
 
 type ArgsToResult = (HashMap<String, ArgumentValue>, IndexMap<String, Item>);
 
@@ -258,6 +259,10 @@ impl<'a> RequestHandler<'a> {
                 Some(t1) => Self::compare_values(t1, t2),
                 None => left == right,
             },
+            (ArgumentValue::Scalar(PrismaValue::Float(s1)), ArgumentValue::Scalar(PrismaValue::String(s2)))
+            | (ArgumentValue::Scalar(PrismaValue::String(s2)), ArgumentValue::Scalar(PrismaValue::Float(s1))) => {
+                BigDecimal::from_str(s2).map(|s2| s2 == *s1).unwrap_or(false)
+            }
             (left, right) => left == right,
         }
     }