[WIP] Resolve relations with lateral joins

.envrc

@@ -20,7 +20,7 @@ export SIMPLE_TEST_MODE="yes" # Reduces the amount of generated `relation_link_t
 ### QE specific logging vars ###
 export QE_LOG_LEVEL=debug # Set it to "trace" to enable query-graph debugging logs
 # export PRISMA_RENDER_DOT_FILE=1 # Uncomment to enable rendering a dot file of the Query Graph from an executed query.
-# export FMT_SQL=1 # Uncomment it to enable logging formatted SQL queries
+export FMT_SQL=1 # Uncomment it to enable logging formatted SQL queries
 
 ### Uncomment to run driver adapters tests. See query-engine-driver-adapters.yml workflow for how tests run in CI.
 # export EXTERNAL_TEST_EXECUTOR="napi"

libs/prisma-value/src/lib.rs

@@ -304,6 +304,14 @@ impl PrismaValue {
             _ => None,
         }
     }
+
+    pub fn as_json(&self) -> Option<&String> {
+        if let Self::Json(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
 }
 
 impl fmt::Display for PrismaValue {

psl/builtin-connectors/src/cockroach_datamodel_connector.rs

@@ -58,7 +58,8 @@ const CAPABILITIES: ConnectorCapabilities = enumflags2::make_bitflags!(Connector
     FilteredInlineChildNestedToOneDisconnect |
     InsertReturning |
     UpdateReturning |
-    RowIn
+    RowIn |
+    LateralJoin
 });
 
 const SCALAR_TYPE_DEFAULTS: &[(ScalarType, CockroachType)] = &[

psl/builtin-connectors/src/postgres_datamodel_connector.rs

@@ -65,7 +65,8 @@ const CAPABILITIES: ConnectorCapabilities = enumflags2::make_bitflags!(Connector
     NativeUpsert |
     InsertReturning |
     UpdateReturning |
-    RowIn
+    RowIn |
+    LateralJoin
 });
 
 pub struct PostgresDatamodelConnector;

psl/psl-core/src/common/preview_features.rs

@@ -76,6 +76,7 @@ features!(
     TransactionApi,
     UncheckedScalarInputs,
     Views,
+    Joins
 );
 
 /// Generator preview features
@@ -90,6 +91,7 @@ pub const ALL_PREVIEW_FEATURES: FeatureMap = FeatureMap {
          | PostgresqlExtensions
          | Tracing
          | Views
+         | Joins
     }),
     deprecated: enumflags2::make_bitflags!(PreviewFeature::{
         AtomicNumberOperations

psl/psl-core/src/datamodel_connector/capabilities.rs

@@ -104,6 +104,7 @@ capabilities!(
     InsertReturning,
     UpdateReturning,
     RowIn, // Connector supports (a, b) IN (c, d) expression.
+    LateralJoin,
 );
 
 /// Contains all capabilities that the connector is able to serve.

psl/psl/tests/config/generators.rs

@@ -258,7 +258,7 @@ fn nice_error_for_unknown_generator_preview_feature() {
         .unwrap_err();
 
     let expectation = expect![[r#"
-        error: The preview feature "foo" is not known. Expected one of: deno, driverAdapters, fullTextIndex, fullTextSearch, metrics, multiSchema, postgresqlExtensions, tracing, views
+        error: The preview feature "foo" is not known. Expected one of: deno, driverAdapters, fullTextIndex, fullTextSearch, metrics, multiSchema, postgresqlExtensions, tracing, views, joins
           -->  schema.prisma:3
            | 
          2 |   provider = "prisma-client-js"

quaint/src/ast/function.rs

@@ -3,6 +3,8 @@ mod average;
 mod coalesce;
 mod concat;
 mod count;
+mod json_array_agg;
+mod json_build_obj;
 #[cfg(any(feature = "postgresql", feature = "mysql"))]
 mod json_extract;
 #[cfg(any(feature = "postgresql", feature = "mysql"))]
@@ -28,6 +30,8 @@ pub use average::*;
 pub use coalesce::*;
 pub use concat::*;
 pub use count::*;
+pub use json_array_agg::*;
+pub use json_build_obj::*;
 #[cfg(any(feature = "postgresql", feature = "mysql"))]
 pub use json_extract::*;
 #[cfg(any(feature = "postgresql", feature = "mysql"))]
@@ -98,6 +102,8 @@ pub(crate) enum FunctionType<'a> {
     JsonExtractFirstArrayElem(JsonExtractFirstArrayElem<'a>),
     #[cfg(any(feature = "postgresql", feature = "mysql"))]
     JsonUnquote(JsonUnquote<'a>),
+    JsonArrayAgg(JsonArrayAgg<'a>),
+    JsonBuildObject(JsonBuildObject<'a>),
     #[cfg(any(feature = "postgresql", feature = "mysql"))]
     TextSearch(TextSearch<'a>),
     #[cfg(any(feature = "postgresql", feature = "mysql"))]
@@ -154,5 +160,7 @@ function!(
     Minimum,
     Maximum,
     Coalesce,
-    Concat
+    Concat,
+    JsonArrayAgg,
+    JsonBuildObject
 );

quaint/src/ast/function/json_array_agg.rs

@@ -0,0 +1,18 @@
+use crate::prelude::*;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct JsonArrayAgg<'a> {
+    pub(crate) expr: Box<Expression<'a>>,
+}
+
+/// Builds a JSON array out of a list of values.
+pub fn json_array_agg<'a, E>(expr: E) -> Function<'a>
+where
+    E: Into<Expression<'a>>,
+{
+    let fun = JsonArrayAgg {
+        expr: Box::new(expr.into()),
+    };
+
+    fun.into()
+}

quaint/src/ast/function/json_build_obj.rs

@@ -0,0 +1,15 @@
+use std::borrow::Cow;
+
+use crate::prelude::*;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct JsonBuildObject<'a> {
+    pub(crate) exprs: Vec<(Cow<'a, str>, Expression<'a>)>,
+}
+
+/// Builds a JSON object out of a list of key-value pairs.
+pub fn json_build_object<'a>(exprs: Vec<(Cow<'a, str>, Expression<'a>)>) -> Function<'a> {
+    let fun = JsonBuildObject { exprs };
+
+    fun.into()
+}

quaint/src/ast/join.rs

@@ -5,6 +5,7 @@ use crate::ast::{ConditionTree, Table};
 pub struct JoinData<'a> {
     pub(crate) table: Table<'a>,
     pub(crate) conditions: ConditionTree<'a>,
+    pub(crate) lateral: bool,
 }
 
 impl<'a> JoinData<'a> {
@@ -13,8 +14,14 @@ impl<'a> JoinData<'a> {
         Self {
             table: table.into(),
             conditions: ConditionTree::NoCondition,
+            lateral: false,
         }
     }
+
+    pub fn lateral(mut self) -> Self {
+        self.lateral = true;
+        self
+    }
 }
 
 impl<'a, T> From<T> for JoinData<'a>
@@ -73,6 +80,7 @@ where
         JoinData {
             table: self.into(),
             conditions: conditions.into(),
+            lateral: false,
         }
     }
 }
@@ -90,6 +98,7 @@ impl<'a> Joinable<'a> for JoinData<'a> {
         JoinData {
             table: self.table,
             conditions,
+            lateral: false,
         }
     }
 }

quaint/src/ast/select.rs

@@ -391,6 +391,15 @@ impl<'a> Select<'a> {
         self
     }
 
+    pub fn left_join_lateral<J>(self, join: J) -> Self
+    where
+        J: Into<JoinData<'a>>,
+    {
+        let join_data: JoinData = join.into();
+
+        self.left_join(join_data.lateral())
+    }
+
     /// Adds `RIGHT JOIN` clause to the query.
     ///
     /// ```rust

quaint/src/ast/table.rs

@@ -204,6 +204,15 @@ impl<'a> Table<'a> {
         self
     }
 
+    pub fn left_join_lateral<J>(self, join: J) -> Self
+    where
+        J: Into<JoinData<'a>>,
+    {
+        let join_data: JoinData = join.into();
+
+        self.left_join(join_data.lateral())
+    }
+
     /// Adds an `INNER JOIN` clause to the query, specifically for that table.
     /// Useful to positionally add a JOIN clause in case you are selecting from multiple tables.
     ///

quaint/src/visitor.rs

@@ -188,18 +188,38 @@ pub trait Visitor<'a> {
             match j {
                 Join::Inner(data) => {
                     self.write(" INNER JOIN ")?;
+
+                    if data.lateral {
+                        self.write("LATERAL ")?;
+                    }
+
                     self.visit_join_data(data)?;
                 }
                 Join::Left(data) => {
                     self.write(" LEFT JOIN ")?;
+
+                    if data.lateral {
+                        self.write("LATERAL ")?;
+                    }
+
                     self.visit_join_data(data)?;
                 }
                 Join::Right(data) => {
                     self.write(" RIGHT JOIN ")?;
+
+                    if data.lateral {
+                        self.write("LATERAL ")?;
+                    }
+
                     self.visit_join_data(data)?;
                 }
                 Join::Full(data) => {
                     self.write(" FULL JOIN ")?;
+
+                    if data.lateral {
+                        self.write("LATERAL ")?;
+                    }
+
                     self.visit_join_data(data)?;
                 }
             }
@@ -1106,6 +1126,27 @@ pub trait Visitor<'a> {
             FunctionType::Concat(concat) => {
                 self.visit_concat(concat)?;
             }
+            FunctionType::JsonArrayAgg(array_agg) => {
+                self.write("JSON_AGG")?;
+                self.surround_with("(", ")", |s| s.visit_expression(*array_agg.expr))?;
+            }
+            FunctionType::JsonBuildObject(build_obj) => {
+                let len = build_obj.exprs.len();
+
+                self.write("JSON_BUILD_OBJECT")?;
+                self.surround_with("(", ")", |s| {
+                    for (i, (name, expr)) in build_obj.exprs.into_iter().enumerate() {
+                        s.visit_raw_value(Value::text(name))?;
+                        s.write(", ")?;
+                        s.visit_expression(expr)?;
+                        if i < (len - 1) {
+                            s.write(", ")?;
+                        }
+                    }
+
+                    Ok(())
+                })?;
+            }
         };
 
         if let Some(alias) = fun.alias {

query-engine/connector-test-kit-rs/query-engine-tests/tests/new/multi_schema.rs

@@ -434,7 +434,7 @@ mod multi_schema {
         insta::assert_snapshot!(
           run_query!(&runner, r#"
                 query {
-                    findManyCategoriesOnPosts(where: {postId: {gt: 0}}) {
+                    findManyCategoriesOnPosts(orderBy: [{ postId: asc }, { categoryId: asc }], where: {postId: {gt: 0}}) {
                       category {
                         name
                       },

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

@@ -11,8 +11,7 @@ mod not_in_batching {
         assert_error!(
             runner,
             "query { findManyTestModel(where: { id: { notIn: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] } }) { id }}",
-            2029,
-            "Parameter limits for this database provider require this query to be split into multiple queries, but the negation filters used prevent the query from being split. Please reduce the used values in the query."
+            2029 // QueryParameterLimitExceeded
         );
 
         Ok(())
@@ -30,8 +29,7 @@ mod not_in_batching_cockroachdb {
         assert_error!(
             runner,
             "query { findManyTestModel(where: { id: { notIn: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] } }) { id }}",
-            2029,
-            "Parameter limits for this database provider require this query to be split into multiple queries, but the negation filters used prevent the query from being split. Please reduce the used values in the query."
+            2029 // QueryParameterLimitExceeded
         );
 
         Ok(())

query-engine/connector-test-kit-rs/query-engine-tests/tests/queries/batch/in_selection_batching.rs

@@ -35,7 +35,9 @@ mod isb {
     }
 
     // "batching of IN queries" should "work when having more than the specified amount of items"
-    #[connector_test]
+    // TODO(joins): Excluded because we have no support for batched queries with joins. In practice, it should happen under much less circumstances
+    // TODO(joins): than with the query-based strategy, because we don't issue `WHERE IN (parent_ids)` queries anymore to resolve relations.
+    #[connector_test(exclude_features("joins"))]
     async fn in_more_items(runner: Runner) -> TestResult<()> {
         create_test_data(&runner).await?;
 
@@ -51,7 +53,9 @@ mod isb {
     }
 
     // "ascending ordering of batched IN queries" should "work when having more than the specified amount of items"
-    #[connector_test]
+    // TODO(joins): Excluded because we have no support for batched queries with joins. In practice, it should happen under much less circumstances
+    // TODO(joins): than with the query-based strategy, because we don't issue `WHERE IN (parent_ids)` queries anymore to resolve relations.
+    #[connector_test(exclude_features("joins"))]
     async fn asc_in_ordering(runner: Runner) -> TestResult<()> {
         create_test_data(&runner).await?;
 
@@ -67,7 +71,9 @@ mod isb {
     }
 
     // "ascending ordering of batched IN queries" should "work when having more than the specified amount of items"
-    #[connector_test]
+    // TODO(joins): Excluded because we have no support for batched queries with joins. In practice, it should happen under much less circumstances
+    // TODO(joins): than with the query-based strategy, because we don't issue `WHERE IN (parent_ids)` queries anymore to resolve relations.
+    #[connector_test(exclude_features("joins"))]
     async fn desc_in_ordering(runner: Runner) -> TestResult<()> {
         create_test_data(&runner).await?;
 
@@ -91,8 +97,7 @@ mod isb {
             r#"query {
               findManyA(where: {id: { in: [5,4,3,2,1,1,1,2,3,4,5,6,7,6,5,4,3,2,1,2,3,4,5,6] }}, orderBy: { b: { as: { _count: asc } } }) { id }
             }"#,
-            2029,
-            "Your query cannot be split into multiple queries because of the order by aggregation or relevance."
+            2029 // QueryParameterLimitExceeded
         );
 
         Ok(())
@@ -107,8 +112,7 @@ mod isb {
             r#"query {
               findManyA(where: {id: { in: [5,4,3,2,1,1,1,2,3,4,5,6,7,6,5,4,3,2,1,2,3,4,5,6] }}, orderBy: { _relevance: { fields: text, search: "something", sort: asc } }) { id }
             }"#,
-            2029,
-            "Your query cannot be split into multiple queries because of the order by aggregation or relevance."
+            2029 // QueryParameterLimitExceeded
         );
 
         Ok(())

query-engine/connector-test-kit-rs/query-engine-tests/tests/queries/data_types/mod.rs

@@ -8,3 +8,4 @@ mod float;
 mod int;
 mod json;
 mod string;
+mod through_relation;