Remove eager default evaluation

Author: aqrln

Cargo.lock

@@ -85,7 +85,6 @@ mongodb = { version = "3", features = [
 ] }
 mysql_async = { git = "https://github.com/prisma/mysql_async", branch = "vendored-openssl" }
 names = { version = "0.11", default-features = false }
-nanoid = "0.4"
 native-tls = "0.2"
 nom = "7"
 num_cpus = "1"

Cargo.toml

@@ -14,9 +14,7 @@ psl.workspace = true
 indexmap.workspace = true
 itertools.workspace = true
 petgraph.workspace = true
-query-structure = { workspace = true, features = [
-    "default_generators",
-] }
+query-structure.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 smallvec.workspace = true

query-compiler/core/Cargo.toml

@@ -4,30 +4,18 @@ use bigdecimal::{BigDecimal, ToPrimitive};
 use chrono::prelude::*;
 use core::fmt;
 use indexmap::{IndexMap, IndexSet};
-use query_structure::{DefaultKind, PrismaValue, ValueGeneratorFn};
+use query_structure::PrismaValue;
 use std::{borrow::Cow, convert::TryFrom, rc::Rc, str::FromStr};
 use user_facing_errors::query_engine::validation::ValidationError;
 use uuid::Uuid;
 
-pub(crate) enum QueryDocumentParser {
-    WithEagerDefaultEvaluation {
-        /// NOW() default value that's reused for all NOW() defaults on a single query
-        default_now: PrismaValue,
-    },
-    WithoutEagerDefaultEvaluation,
-}
+pub(crate) struct QueryDocumentParser;
 
 type ResolveField<'a, 'b> = &'b dyn Fn(&str) -> Option<OutputField<'a>>;
 
 impl QueryDocumentParser {
-    pub(crate) fn with_eager_default_evaluation() -> Self {
-        QueryDocumentParser::WithEagerDefaultEvaluation {
-            default_now: crate::request_context::get_request_now(),
-        }
-    }
-
-    pub(crate) fn without_eager_default_evaluation() -> Self {
-        QueryDocumentParser::WithoutEagerDefaultEvaluation
+    pub(crate) fn new() -> Self {
+        Self
     }
 
     // Public entry point to parsing the query document (as denoted by `selections`) against the `schema_object`.
@@ -712,20 +700,10 @@ impl QueryDocumentParser {
                 // If it's not optional and has no default, a required field has not been provided.
                 match &field.default_value {
                     Some(default_value) => {
-                        let default_pv = match self {
-                            Self::WithEagerDefaultEvaluation { default_now } => match default_value {
-                                DefaultKind::Expression(expr) if matches!(expr.generator(), ValueGeneratorFn::Now) => {
-                                    default_now.clone()
-                                }
-                                _ => default_value.get_evaluated()?,
-                            },
-                            Self::WithoutEagerDefaultEvaluation => default_value.get()?,
-                        };
-
                         match self.parse_input_value(
                             selection_path.clone(),
                             argument_path,
-                            default_pv.into(),
+                            default_value.get()?.into(),
                             field.field_types(),
                             query_schema,
                         ) {

query-compiler/core/src/query_document/parser.rs

@@ -32,8 +32,6 @@ static PRISMA_DOT_PATH: LazyLock<Option<String>> = LazyLock::new(|| {
 
 pub struct QueryGraphBuilder<'a> {
     query_schema: &'a QuerySchema,
-    // TODO: remove this mode, it was only used by QE
-    eager_default_evaluation: bool,
 }
 
 impl fmt::Debug for QueryGraphBuilder<'_> {
@@ -44,17 +42,7 @@ impl fmt::Debug for QueryGraphBuilder<'_> {
 
 impl<'a> QueryGraphBuilder<'a> {
     pub fn new(query_schema: &'a QuerySchema) -> Self {
-        Self {
-            query_schema,
-            eager_default_evaluation: true,
-        }
-    }
-
-    /// Disables eager evaluation of default values of columns. Instead of passing through
-    /// evaluated defaults, they are passed through as reified generator calls.
-    pub fn without_eager_default_evaluation(mut self) -> Self {
-        self.eager_default_evaluation = false;
-        self
+        Self { query_schema }
     }
 
     /// Maps an operation to a query.
@@ -76,11 +64,7 @@ impl<'a> QueryGraphBuilder<'a> {
         root_object: ObjectType<'a>, // Either the query or mutation object.
         root_object_fields: &dyn Fn(&str) -> Option<OutputField<'a>>,
     ) -> QueryGraphBuilderResult<QueryGraph> {
-        let parser = if self.eager_default_evaluation {
-            QueryDocumentParser::with_eager_default_evaluation()
-        } else {
-            QueryDocumentParser::without_eager_default_evaluation()
-        };
+        let parser = QueryDocumentParser::new();
 
         let mut parsed_object = parser.parse(
             slice::from_ref(&selection),

query-compiler/core/src/query_graph_builder/builder.rs

@@ -11,9 +11,7 @@ serde.workspace = true
 serde_json.workspace = true
 schema.workspace = true
 indexmap = { workspace = true, features = ["serde"] }
-query-structure = { workspace = true, features = [
-    "default_generators",
-] }
+query-structure.workspace = true
 
 [dev-dependencies]
 expect-test.workspace = true

query-compiler/dmmf/Cargo.toml

@@ -22,4 +22,3 @@ quaint = { workspace = true, features = ["mysql", "mssql", "postgresql", "sqlite
 
 [features]
 relation_joins = ["query-builder/relation_joins"]
-default_generators = ["query-structure/default_generators"]

query-compiler/query-builders/sql-query-builder/Cargo.toml

@@ -74,9 +74,7 @@ pub fn main() -> anyhow::Result<()> {
         anyhow::bail!("expected single query");
     };
 
-    let graph = QueryGraphBuilder::new(&query_schema)
-        .without_eager_default_evaluation()
-        .build(query)?;
+    let graph = QueryGraphBuilder::new(&query_schema).build(query)?;
 
     println!("{graph}");
     render_query_graph(&graph)?;

query-compiler/query-compiler-playground/src/main.rs

@@ -35,9 +35,7 @@ pub fn compile(
     connection_info: &ConnectionInfo,
 ) -> Result<Expression, CompileError> {
     let ctx = Context::new(connection_info, None);
-    let graph = QueryGraphBuilder::new(query_schema)
-        .without_eager_default_evaluation()
-        .build(query)?;
+    let graph = QueryGraphBuilder::new(query_schema).build(query)?;
 
     let res: Result<Expression, TranslateError> = match connection_info.sql_family() {
         #[cfg(feature = "postgresql")]

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

@@ -40,7 +40,6 @@ fn queries() {
         };
 
         let graph = QueryGraphBuilder::new(&query_schema)
-            .without_eager_default_evaluation()
             .build(query)
             .map_err(|err| format!("{test_name} failed: {err}"))
             .unwrap();