Resolve view query sources by lexical scope

Author: LucaCappelletti94

diesel_cli/src/infer_schema_internals/inference.rs

@@ -394,15 +394,21 @@ pub fn load_view_data(
                 {
                     tracing::debug!(view = %name, ?data, "Inferred data");
                     if data.field_count() == column_data.len() {
-                        for (column_data, is_nullable) in column_data
-                            .iter_mut()
-                            .zip(data.infer_nullability(resolver)?)
-                        {
-                            tracing::debug!(view = %name, field = %column_data.rust_name, ?is_nullable, "Correct field nullablility");
-                            match is_nullable {
-                                IsNull::IsNullable => column_data.ty.is_nullable = true,
-                                IsNull::NotNullable => column_data.ty.is_nullable = false,
-                                IsNull::Unknown => {}
+                        match data.infer_nullability(resolver) {
+                            Ok(nullability) => {
+                                for (column_data, is_nullable) in
+                                    column_data.iter_mut().zip(nullability)
+                                {
+                                    tracing::debug!(view = %name, field = %column_data.rust_name, ?is_nullable, "Correct field nullablility");
+                                    match is_nullable {
+                                        IsNull::IsNullable => column_data.ty.is_nullable = true,
+                                        IsNull::NotNullable => column_data.ty.is_nullable = false,
+                                        IsNull::Unknown => {}
+                                    }
+                                }
+                            }
+                            Err(e) => {
+                                tracing::warn!(view = %name, error = %e, "Failed to infer nullability for view fields");
                             }
                         }
                     } else {

diesel_cli/tests/print_schema.rs

@@ -568,6 +568,15 @@ fn print_schema_view_infer_nullable_simple() {
     )
 }
 
+#[test]
+#[cfg(feature = "sqlite")]
+fn print_schema_view_infer_nullable_resolution_failure() {
+    test_print_schema(
+        "print_schema_view_infer_nullable_resolution_failure",
+        vec!["--include-views", "--experimental-infer-nullable-for-views"],
+    );
+}
+
 #[test]
 fn print_schema_view_infer_nullable_from_table() {
     test_print_schema(

diesel_cli/tests/print_schema/print_schema_view_infer_nullable_resolution_failure/diesel.toml

@@ -0,0 +1,5 @@
+[print_schema]
+file = "src/schema.rs"
+with_docs = false
+include_views = true
+experimental_infer_nullable_for_views = true

diesel_cli/tests/print_schema/print_schema_view_infer_nullable_resolution_failure/sqlite/expected.snap

@@ -0,0 +1,11 @@
+---
+source: diesel_cli/tests/print_schema.rs
+description: "Test: print_schema_view_infer_nullable_resolution_failure"
+---
+// @generated automatically by Diesel CLI.
+
+diesel::view! {
+    v {
+        a -> Nullable<Binary>,
+    }
+}

diesel_cli/tests/print_schema/print_schema_view_infer_nullable_resolution_failure/sqlite/schema.sql

@@ -0,0 +1 @@
+CREATE VIEW v AS SELECT s."1 + 2" AS a FROM (SELECT 1 + 2) s;

diesel_infer_query/Cargo.toml

@@ -11,9 +11,6 @@ autotests = false
 sqlparser = { version = "0.63.0", features = ["visitor"] }
 thiserror = "2"
 
-[dev-dependencies]
-insta = "1.43"
-
 [[test]]
 path = "tests/lib.rs"
 name = "integration_tests"

diesel_infer_query/src/expression.rs

@@ -5,6 +5,7 @@
 use crate::error::{Error, Result};
 use crate::query_source::QuerySource;
 use crate::select::{CaseCondition, Expression};
+use crate::views::ParseContext;
 use sqlparser::ast::{
     Expr, FunctionArg, FunctionArgExpr, FunctionArguments, ObjectNamePart, Value,
 };
@@ -13,6 +14,7 @@ use std::collections::HashMap;
 pub(crate) fn infer_expr(
     expr: &sqlparser::ast::Expr,
     query_source_lookup: &HashMap<Option<&str>, QuerySource>,
+    context: &mut ParseContext,
 ) -> Result<Expression> {
     match expr {
         Expr::Value(v) => Ok(Expression::Literal {
@@ -29,6 +31,7 @@ pub(crate) fn infer_expr(
                     schema: table.schema.map(|s| s.to_owned()),
                     query_source: table.name.map(|s| s.to_owned()),
                     field_name: id.value.clone(),
+                    source_id: table.source_id,
                     // no joins here so we should be fine
                     via_left_join: false,
                 })
@@ -53,6 +56,7 @@ pub(crate) fn infer_expr(
                     schema: table.schema.map(|s| s.to_owned()),
                     query_source: table.name.map(|s| s.to_owned()),
                     field_name: field.value.clone(),
+                    source_id: table.source_id,
                     via_left_join,
                 })
             }
@@ -65,15 +69,15 @@ pub(crate) fn infer_expr(
         Expr::Cast {
             expr, data_type, ..
         } => {
-            let inner = infer_expr(expr, query_source_lookup)?;
+            let inner = infer_expr(expr, query_source_lookup, context)?;
             Ok(Expression::Cast {
                 inner: Box::new(inner),
                 tpe: data_type.to_string(),
             })
         }
         Expr::BinaryOp { left, op, right } => {
-            let left = Box::new(infer_expr(left, query_source_lookup)?);
-            let right = Box::new(infer_expr(right, query_source_lookup)?);
+            let left = Box::new(infer_expr(left, query_source_lookup, context)?);
+            let right = Box::new(infer_expr(right, query_source_lookup, context)?);
             Ok(Expression::BinaryOp {
                 left,
                 right,
@@ -82,22 +86,22 @@ pub(crate) fn infer_expr(
             })
         }
         Expr::IsNull(e) => {
-            let inner = Box::new(infer_expr(e, query_source_lookup)?);
+            let inner = Box::new(infer_expr(e, query_source_lookup, context)?);
             Ok(Expression::PostfixOp {
                 expr: inner,
                 op: String::from("IS NULL"),
                 statically_not_null: true,
             })
         }
         Expr::IsNotNull(e) => {
-            let inner = Box::new(infer_expr(e, query_source_lookup)?);
+            let inner = Box::new(infer_expr(e, query_source_lookup, context)?);
             Ok(Expression::PostfixOp {
                 expr: inner,
                 op: String::from("IS NOT NULL"),
                 statically_not_null: true,
             })
         }
-        Expr::Function(f) => infer_functions(f, query_source_lookup),
+        Expr::Function(f) => infer_functions(f, query_source_lookup, context),
         Expr::Like {
             negated,
             any,
@@ -107,8 +111,8 @@ pub(crate) fn infer_expr(
         } if !*any && escape_char.is_none() => {
             let op = if *negated { "NOT LIKE" } else { "LIKE" };
             Ok(Expression::BinaryOp {
-                left: Box::new(infer_expr(expr, query_source_lookup)?),
-                right: Box::new(infer_expr(pattern, query_source_lookup)?),
+                left: Box::new(infer_expr(expr, query_source_lookup, context)?),
+                right: Box::new(infer_expr(pattern, query_source_lookup, context)?),
                 op: String::from(op),
                 statically_not_null: false,
             })
@@ -122,21 +126,21 @@ pub(crate) fn infer_expr(
         } if !*any && escape_char.is_none() => {
             let op = if *negated { "NOT ILIKE" } else { "ILIKE" };
             Ok(Expression::BinaryOp {
-                left: Box::new(infer_expr(expr, query_source_lookup)?),
-                right: Box::new(infer_expr(pattern, query_source_lookup)?),
+                left: Box::new(infer_expr(expr, query_source_lookup, context)?),
+                right: Box::new(infer_expr(pattern, query_source_lookup, context)?),
                 op: String::from(op),
                 statically_not_null: false,
             })
         }
         Expr::IsDistinctFrom(a, b) => Ok(Expression::BinaryOp {
-            left: Box::new(infer_expr(a, query_source_lookup)?),
-            right: Box::new(infer_expr(b, query_source_lookup)?),
+            left: Box::new(infer_expr(a, query_source_lookup, context)?),
+            right: Box::new(infer_expr(b, query_source_lookup, context)?),
             op: String::from("IS DISTINCT FROM"),
             statically_not_null: true,
         }),
         Expr::IsNotDistinctFrom(a, b) => Ok(Expression::BinaryOp {
-            left: Box::new(infer_expr(a, query_source_lookup)?),
-            right: Box::new(infer_expr(b, query_source_lookup)?),
+            left: Box::new(infer_expr(a, query_source_lookup, context)?),
+            right: Box::new(infer_expr(b, query_source_lookup, context)?),
             op: String::from("IS NOT DISTINCT FROM"),
             statically_not_null: true,
         }),
@@ -146,10 +150,10 @@ pub(crate) fn infer_expr(
             low,
             high,
         } => Ok(Expression::Between {
-            left: Box::new(infer_expr(expr, query_source_lookup)?),
+            left: Box::new(infer_expr(expr, query_source_lookup, context)?),
             negated: *negated,
-            low: Box::new(infer_expr(low, query_source_lookup)?),
-            high: Box::new(infer_expr(high, query_source_lookup)?),
+            low: Box::new(infer_expr(low, query_source_lookup, context)?),
+            high: Box::new(infer_expr(high, query_source_lookup, context)?),
         }),
         Expr::SimilarTo {
             negated,
@@ -163,8 +167,8 @@ pub(crate) fn infer_expr(
                 "SIMILAR TO"
             };
             Ok(Expression::BinaryOp {
-                left: Box::new(infer_expr(expr, query_source_lookup)?),
-                right: Box::new(infer_expr(pattern, query_source_lookup)?),
+                left: Box::new(infer_expr(expr, query_source_lookup, context)?),
+                right: Box::new(infer_expr(pattern, query_source_lookup, context)?),
                 op: String::from(op),
                 statically_not_null: false,
             })
@@ -183,8 +187,8 @@ pub(crate) fn infer_expr(
                 "RLIKE"
             };
             Ok(Expression::BinaryOp {
-                left: Box::new(infer_expr(expr, query_source_lookup)?),
-                right: Box::new(infer_expr(pattern, query_source_lookup)?),
+                left: Box::new(infer_expr(expr, query_source_lookup, context)?),
+                right: Box::new(infer_expr(pattern, query_source_lookup, context)?),
                 op: String::from(op),
                 statically_not_null: false,
             })
@@ -197,19 +201,19 @@ pub(crate) fn infer_expr(
         } => {
             let operand = operand
                 .as_ref()
-                .map(|o| infer_expr(o, query_source_lookup))
+                .map(|o| infer_expr(o, query_source_lookup, context))
                 .transpose()?
                 .map(Box::new);
             let else_clause = else_result
                 .as_ref()
-                .map(|e| infer_expr(e, query_source_lookup))
+                .map(|e| infer_expr(e, query_source_lookup, context))
                 .transpose()?
                 .map(Box::new);
             let conditions = conditions
                 .iter()
                 .map(|c| -> std::result::Result<_, _> {
-                    let condition = infer_expr(&c.condition, query_source_lookup)?;
-                    let result = infer_expr(&c.result, query_source_lookup)?;
+                    let condition = infer_expr(&c.condition, query_source_lookup, context)?;
+                    let result = infer_expr(&c.result, query_source_lookup, context)?;
                     Ok(CaseCondition { condition, result })
                 })
                 .collect::<Result<Vec<_>>>()?;
@@ -224,28 +228,28 @@ pub(crate) fn infer_expr(
             list,
             negated,
         } => Ok(Expression::In {
-            left: Box::new(infer_expr(expr, query_source_lookup)?),
+            left: Box::new(infer_expr(expr, query_source_lookup, context)?),
             negated: *negated,
             list: list
                 .iter()
-                .map(|e| infer_expr(e, query_source_lookup))
+                .map(|e| infer_expr(e, query_source_lookup, context))
                 .collect::<Result<Vec<_>, _>>()?,
         }),
-        Expr::Nested(n) => infer_expr(n, query_source_lookup)
+        Expr::Nested(n) => infer_expr(n, query_source_lookup, context)
             .map(Box::new)
             .map(Expression::Grouped),
         Expr::Subquery(query) => {
-            let results = crate::select::parse_query(query, Some(query_source_lookup))?;
+            let results = crate::select::parse_query(query, Some(query_source_lookup), context)?;
             Ok(Expression::Subquery { selection: results })
         }
         Expr::InSubquery {
             expr,
             subquery,
             negated,
         } => {
-            let results = crate::select::parse_query(subquery, Some(query_source_lookup))?;
+            let results = crate::select::parse_query(subquery, Some(query_source_lookup), context)?;
             Ok(Expression::InSubQuery {
-                left: Box::new(infer_expr(expr, query_source_lookup)?),
+                left: Box::new(infer_expr(expr, query_source_lookup, context)?),
                 negated: *negated,
                 subquery: results,
             })
@@ -304,6 +308,7 @@ pub(crate) fn infer_expr(
 fn infer_functions(
     f: &sqlparser::ast::Function,
     query_source_lookup: &HashMap<Option<&str>, QuerySource<'_>>,
+    context: &mut ParseContext,
 ) -> Result<Expression> {
     let (name, schema) = match f.name.0.as_slice() {
         [ObjectNamePart::Identifier(name)] => (&name.value, None),
@@ -321,7 +326,7 @@ fn infer_functions(
                 FunctionArg::Named { arg, .. }
                 | FunctionArg::ExprNamed { arg, .. }
                 | FunctionArg::Unnamed(arg) => match arg {
-                    FunctionArgExpr::Expr(expr) => infer_expr(expr, query_source_lookup),
+                    FunctionArgExpr::Expr(expr) => infer_expr(expr, query_source_lookup, context),
                     FunctionArgExpr::QualifiedWildcard(object_name) => {
                         if let Some(item) = object_name
                             .0
@@ -334,6 +339,7 @@ fn infer_functions(
                             Ok(Expression::Wildcard {
                                 is_left_joined,
                                 relation: item.name.map(|s| s.to_owned()),
+                                source_id: item.source_id,
                                 schema: item.schema.map(|t| t.to_owned()),
                             })
                         } else {
@@ -349,6 +355,7 @@ fn infer_functions(
                             is_left_joined: false,
                             relation: query_source_lookup.name.map(|s| s.to_owned()),
                             schema: query_source_lookup.schema.map(|t| t.to_owned()),
+                            source_id: query_source_lookup.source_id,
                         })
                     }
                     FunctionArgExpr::WildcardWithOptions(_) | FunctionArgExpr::Wildcard => {

diesel_infer_query/src/query_source.rs

@@ -56,6 +56,7 @@ pub(crate) struct QuerySource<'a> {
     pub(crate) schema: Option<&'a str>,
     /// The name of the query source
     pub(crate) name: Option<&'a str>,
+    pub(crate) source_id: Option<usize>,
     /// The alias that is used to refer to this query source in the query
     #[expect(dead_code, reason = "its there for later")]
     pub(crate) alias: Option<&'a str>,
@@ -160,6 +161,7 @@ impl<'a> QuerySource<'a> {
                         schema,
                         name: Some(name),
                         alias,
+                        source_id: None,
                         join: None,
                     },
                 );
@@ -177,6 +179,7 @@ impl<'a> QuerySource<'a> {
                     schema: None,
                     name: Some(&alias.name.value),
                     alias: Some(&alias.name.value),
+                    source_id: None,
                     join: None
                 });
                 Ok(())
@@ -186,6 +189,7 @@ impl<'a> QuerySource<'a> {
                     schema: None,
                     name: None,
                     alias: None,
+                    source_id: None,
                     join: None
                 });
                 Ok(())