polyglot-sql 0.5.9__tar.gz → 0.5.11__tar.gz

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.5.9"
+version = "0.5.11"
 dependencies = [
  "criterion",
  "once_cell",
@@ -621,7 +621,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.5.9"
+version = "0.5.11"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -631,11 +631,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.5.9"
+version = "0.5.11"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.5.9"
+version = "0.5.11"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.5.9"
+version = "0.5.11"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.5.9"
+version = "0.5.11"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.5.9
+Version: 0.5.11
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql/Cargo.toml

@@ -106,7 +106,7 @@ thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.5.9", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.5.11", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -1068,6 +1068,11 @@ impl DialectImpl for DuckDBDialect {
             // WithinGroup: PERCENTILE_CONT/DISC WITHIN GROUP (ORDER BY ...) -> QUANTILE_CONT/DISC(col, quantile ORDER BY ...)
             Expression::WithinGroup(wg) => {
                 match &wg.this {
+                    Expression::ListAgg(listagg) => {
+                        let mut listagg = listagg.clone();
+                        listagg.order_by = Some(wg.order_by.clone());
+                        Ok(Expression::ListAgg(listagg))
+                    }
                     Expression::PercentileCont(p) => {
                         let column = wg
                             .order_by
@@ -7496,7 +7501,11 @@ mod tests {
     use crate::dialects::Dialect;
 
     fn transpile_to_duckdb(sql: &str) -> String {
-        let dialect = Dialect::get(DialectType::Generic);
+        transpile_to_duckdb_from(sql, DialectType::Generic)
+    }
+
+    fn transpile_to_duckdb_from(sql: &str, read: DialectType) -> String {
+        let dialect = Dialect::get(read);
         let result = dialect
             .transpile(sql, DialectType::DuckDB)
             .expect("Transpile failed");
@@ -7550,6 +7559,36 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_ordered_string_agg_uses_duckdb_listagg_order_syntax() {
+        let result = transpile_to_duckdb_from(
+            "SELECT string_agg(nm, ',' ORDER BY id) AS v FROM t",
+            DialectType::PostgreSQL,
+        );
+        assert_eq!(result, "SELECT LISTAGG(nm, ',' ORDER BY id) AS v FROM t");
+    }
+
+    #[test]
+    fn test_ordered_listagg_uses_duckdb_order_syntax() {
+        let result = transpile_to_duckdb_from(
+            "SELECT LISTAGG(col, '|SEPARATOR|') WITHIN GROUP (ORDER BY col2) FROM t",
+            DialectType::Snowflake,
+        );
+        assert_eq!(
+            result,
+            "SELECT LISTAGG(col, '|SEPARATOR|' ORDER BY col2) FROM t"
+        );
+    }
+
+    #[test]
+    fn test_ordered_group_concat_uses_duckdb_listagg_order_syntax() {
+        let result = transpile_to_duckdb_from(
+            "SELECT GROUP_CONCAT(nm ORDER BY id SEPARATOR ',') AS v FROM t",
+            DialectType::MySQL,
+        );
+        assert_eq!(result, "SELECT LISTAGG(nm, ',' ORDER BY id) AS v FROM t");
+    }
+
     #[test]
     fn test_date_format_to_strftime() {
         let result = transpile_to_duckdb("SELECT DATE_FORMAT(d, '%Y-%m-%d')");

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql/src/dialects/mod.rs

@@ -4879,6 +4879,15 @@ impl Dialect {
                 Self::push_unsupported_diagnostic(&mut diagnostics, "ARRAY_AGG");
             }
 
+            if matches!(target, DialectType::TSQL | DialectType::Fabric)
+                && Self::node_is_regex_predicate(node)
+            {
+                Self::push_unsupported_diagnostic(
+                    &mut diagnostics,
+                    "regular expression predicates",
+                );
+            }
+
             if matches!(source, DialectType::PostgreSQL | DialectType::CockroachDB)
                 && !matches!(target, DialectType::PostgreSQL | DialectType::CockroachDB)
             {
@@ -5018,6 +5027,15 @@ impl Dialect {
         matches!(expr, Expression::ArrayAgg(_)) || Self::node_is_function_named(expr, "ARRAY_AGG")
     }
 
+    fn node_is_regex_predicate(expr: &Expression) -> bool {
+        matches!(
+            expr,
+            Expression::SimilarTo(_) | Expression::RegexpLike(_) | Expression::RegexpILike(_)
+        ) || Self::node_is_function_named(expr, "REGEXP_LIKE")
+            || Self::node_is_function_named(expr, "REGEXP_I_LIKE")
+            || Self::node_is_function_named(expr, "REGEXP_ILIKE")
+    }
+
     fn node_is_function_named(expr: &Expression, name: &str) -> bool {
         match expr {
             Expression::Function(function) => function.name.eq_ignore_ascii_case(name),

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql/src/generator.rs

@@ -17924,7 +17924,7 @@ impl Generator {
         {
             self.write_keyword("DATEPART");
             self.write("(");
-            self.generate_expression(&func.args[0])?;
+            self.write_tsql_date_part(&func.args[0])?;
             self.write(", ");
             self.generate_expression(&func.args[1])?;
             self.write(")");
@@ -18888,6 +18888,22 @@ impl Generator {
         }
     }
 
+    fn write_tsql_date_part(&mut self, expr: &Expression) -> Result<()> {
+        if let Some(part) = self.extract_date_part_string(expr) {
+            let upper = part.to_ascii_uppercase();
+            let unmapped = match upper.as_str() {
+                "DAYOFWEEK" => "WEEKDAY",
+                "WEEKISO" => "ISO_WEEK",
+                "TIMEZONE_MINUTE" => "TZOFFSET",
+                _ => part.as_str(),
+            };
+            self.write_keyword(unmapped);
+        } else {
+            self.generate_expression(expr)?;
+        }
+        Ok(())
+    }
+
     /// Extract date part string from expression (handles string literals and identifiers)
     fn extract_date_part_string(&self, expr: &Expression) -> Option<String> {
         match expr {
@@ -20369,6 +20385,7 @@ impl Generator {
 
     fn generate_listagg(&mut self, f: &ListAggFunc) -> Result<()> {
         use crate::dialects::DialectType;
+        let order_inside_args = matches!(self.config.dialect, Some(DialectType::DuckDB));
         self.write_keyword("LISTAGG");
         self.write("(");
         if f.distinct {
@@ -20408,20 +20425,35 @@ impl Generator {
                 }
             }
         }
+        if order_inside_args {
+            if let Some(ref order_by) = f.order_by {
+                self.write_space();
+                self.write_keyword("ORDER BY");
+                self.write_space();
+                for (i, ord) in order_by.iter().enumerate() {
+                    if i > 0 {
+                        self.write(", ");
+                    }
+                    self.generate_ordered(ord)?;
+                }
+            }
+        }
         self.write(")");
-        if let Some(ref order_by) = f.order_by {
-            self.write_space();
-            self.write_keyword("WITHIN GROUP");
-            self.write(" (");
-            self.write_keyword("ORDER BY");
-            self.write_space();
-            for (i, ord) in order_by.iter().enumerate() {
-                if i > 0 {
-                    self.write(", ");
+        if !order_inside_args {
+            if let Some(ref order_by) = f.order_by {
+                self.write_space();
+                self.write_keyword("WITHIN GROUP");
+                self.write(" (");
+                self.write_keyword("ORDER BY");
+                self.write_space();
+                for (i, ord) in order_by.iter().enumerate() {
+                    if i > 0 {
+                        self.write(", ");
+                    }
+                    self.generate_ordered(ord)?;
                 }
-                self.generate_ordered(ord)?;
+                self.write(")");
             }
-            self.write(")");
         }
         if let Some(ref filter) = f.filter {
             self.write_space();

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql/src/lineage.rs

@@ -194,9 +194,11 @@ pub fn lineage_with_schema(
     let normalized_expression = lineage_normalized_expression(sql);
     let mut qualified_expression = if let Some(schema) = schema {
         let options = if let Some(dialect_type) = dialect.or_else(|| schema.dialect()) {
-            QualifyColumnsOptions::new().with_dialect(dialect_type)
-        } else {
             QualifyColumnsOptions::new()
+                .with_dialect(dialect_type)
+                .with_allow_partial(true)
+        } else {
+            QualifyColumnsOptions::new().with_allow_partial(true)
         };
 
         qualify_columns(normalized_expression.clone(), schema, &options).map_err(|e| {
@@ -3705,6 +3707,88 @@ mod tests {
         assert_eq!(expr_with.inferred_type(), Some(&DataType::Text));
     }
 
+    #[test]
+    fn test_lineage_with_schema_tolerates_partial_schema_for_known_column() {
+        let expr = parse_dialect("SELECT order_id, amount FROM t", DialectType::DuckDB);
+        let mut schema = MappingSchema::with_dialect(DialectType::DuckDB);
+        schema
+            .add_table(
+                "t",
+                &[("amount".into(), DataType::BigInt { length: None })],
+                None,
+            )
+            .expect("schema setup");
+
+        let node = lineage_with_schema(
+            "amount",
+            &expr,
+            Some(&schema),
+            Some(DialectType::DuckDB),
+            false,
+        )
+        .expect("lineage_with_schema should tolerate unrelated unknown columns");
+
+        assert_lineage_contains(&node, "t.amount");
+    }
+
+    #[test]
+    fn test_lineage_with_schema_tolerates_partial_schema_for_unknown_column() {
+        let expr = parse_dialect("SELECT order_id, amount FROM t", DialectType::DuckDB);
+        let mut schema = MappingSchema::with_dialect(DialectType::DuckDB);
+        schema
+            .add_table(
+                "t",
+                &[("amount".into(), DataType::BigInt { length: None })],
+                None,
+            )
+            .expect("schema setup");
+
+        let node = lineage_with_schema(
+            "order_id",
+            &expr,
+            Some(&schema),
+            Some(DialectType::DuckDB),
+            false,
+        )
+        .expect("lineage_with_schema should keep unknown selected columns");
+
+        assert_lineage_contains(&node, "t.order_id");
+    }
+
+    #[test]
+    fn test_lineage_with_schema_tolerates_partial_schema_for_join_conditions() {
+        let expr = parse_dialect(
+            "SELECT a.order_id, b.amount FROM t a JOIN u b ON a.id = b.id",
+            DialectType::DuckDB,
+        );
+        let mut schema = MappingSchema::with_dialect(DialectType::DuckDB);
+        schema
+            .add_table(
+                "t",
+                &[("order_id".into(), DataType::BigInt { length: None })],
+                None,
+            )
+            .expect("schema setup");
+        schema
+            .add_table(
+                "u",
+                &[("amount".into(), DataType::BigInt { length: None })],
+                None,
+            )
+            .expect("schema setup");
+
+        let node = lineage_with_schema(
+            "amount",
+            &expr,
+            Some(&schema),
+            Some(DialectType::DuckDB),
+            false,
+        )
+        .expect("lineage_with_schema should tolerate unknown join keys");
+
+        assert_lineage_contains(&node, "b.amount");
+    }
+
     #[test]
     fn test_lineage_with_schema_correlated_scalar_subquery() {
         let query = "SELECT id, (SELECT AVG(val) FROM t2 WHERE t2.id = t1.id) AS avg_val FROM t1";

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql/src/query_analysis.rs

@@ -187,7 +187,9 @@ pub fn analyze_query(sql: &str, options: AnalyzeQueryOptions) -> Result<QueryAna
     let star_projections = star_projection_facts(&original_expression, mapping_schema.as_ref());
 
     if let Some(schema) = mapping_schema.as_ref() {
-        let qualify_options = QualifyColumnsOptions::new().with_dialect(options.dialect);
+        let qualify_options = QualifyColumnsOptions::new()
+            .with_dialect(options.dialect)
+            .with_allow_partial(true);
         expression = qualify_columns(expression, schema, &qualify_options)
             .map_err(|e| Error::internal(format!("query analysis qualification failed: {e}")))?;
     }

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql/src/validation/tests.rs

@@ -217,6 +217,29 @@ fn test_validate_with_schema_unknown_column() {
     );
 }
 
+#[test]
+fn test_validate_with_schema_partial_schema_stays_strict() {
+    let mut schema = base_schema();
+    let users = schema
+        .tables
+        .iter_mut()
+        .find(|table| table.name == "users")
+        .expect("users table");
+    users.columns.retain(|column| column.name == "id");
+
+    let opts = SchemaValidationOptions::default();
+    let result = validate_with_schema(
+        "SELECT id, name FROM users",
+        DialectType::Generic,
+        &schema,
+        &opts,
+    );
+    assert!(!result.valid);
+    assert!(result.errors.iter().any(|error| {
+        error.code == validation_codes::E_UNKNOWN_COLUMN && error.message.contains("name")
+    }));
+}
+
 #[test]
 fn test_validate_with_schema_function_catalog_unknown_function() {
     let schema = base_schema();

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql/tests/issue227_strict_unsupported.rs

@@ -138,6 +138,31 @@ fn strict_transpile_rejects_array_agg_for_lossy_targets() {
     assert!(err.to_string().contains("ARRAY_AGG"));
 }
 
+#[test]
+fn strict_transpile_rejects_regex_predicates_for_tsql_targets() {
+    let sqls = [
+        "SELECT 1 FROM t WHERE p_brand SIMILAR TO 'Brand#[1-3][0-9]'",
+        "SELECT 1 FROM t WHERE c_phone ~ '^1[0-9]'",
+        "SELECT 1 FROM t WHERE c_phone !~ '^1[0-9]'",
+        "SELECT 1 FROM t WHERE c_phone ~* '^1[0-9]'",
+        "SELECT 1 FROM t WHERE c_phone !~* '^1[0-9]'",
+        "SELECT 1 FROM t WHERE REGEXP_LIKE(c_phone, '^1[0-9]')",
+    ];
+
+    for sql in sqls {
+        for write in [DialectType::Fabric, DialectType::TSQL] {
+            let err =
+                transpile_with_level(sql, DialectType::PostgreSQL, write, UnsupportedLevel::Raise)
+                    .expect_err("strict TSQL/Fabric transpile should reject regex predicates");
+
+            assert!(
+                err.to_string().contains("regular expression predicates"),
+                "unexpected error for PostgreSQL -> {write:?}: {err}"
+            );
+        }
+    }
+}
+
 #[test]
 fn strict_transpile_rejects_postgres_only_functions() {
     let err = transpile_with_level(

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql/tests/query_analysis.rs

@@ -736,6 +736,118 @@ fn analyze_query_resolves_unnest_virtual_output_aliases_with_schema() {
     }
 }
 
+#[test]
+fn analyze_query_tolerates_partial_schema_for_unknown_columns() {
+    let analysis = analyze_query(
+        "SELECT order_id, amount FROM t",
+        AnalyzeQueryOptions {
+            dialect: DialectType::DuckDB,
+            schema: Some(single_column_schema(&["t"], "amount")),
+        },
+    )
+    .unwrap();
+
+    assert_eq!(analysis.projections.len(), 2);
+    assert_eq!(analysis.projections[0].name.as_deref(), Some("order_id"));
+    assert_eq!(analysis.projections[1].name.as_deref(), Some("amount"));
+
+    let order_id = &analysis.projections[0].upstream;
+    assert!(
+        order_id.iter().any(|reference| {
+            reference.column == "order_id"
+                && reference.confidence == ReferenceConfidence::Resolved
+                && reference.source_name.as_deref() == Some("t")
+                && reference.table.as_deref() == Some("t")
+        }),
+        "expected best-effort order_id reference, got {order_id:?}"
+    );
+
+    let amount = &analysis.projections[1].upstream;
+    assert!(
+        amount.iter().any(|reference| {
+            reference.column == "amount"
+                && reference.confidence == ReferenceConfidence::Resolved
+                && reference.table.as_deref() == Some("t")
+        }),
+        "expected schema-backed amount reference, got {amount:?}"
+    );
+}
+
+#[test]
+fn analyze_query_tolerates_partial_schema_for_qualified_unknown_columns() {
+    let analysis = analyze_query(
+        "SELECT t.order_id, t.amount FROM t",
+        AnalyzeQueryOptions {
+            dialect: DialectType::DuckDB,
+            schema: Some(single_column_schema(&["t"], "amount")),
+        },
+    )
+    .unwrap();
+
+    assert!(
+        analysis.projections[0].upstream.iter().any(|reference| {
+            reference.column == "order_id"
+                && reference.confidence == ReferenceConfidence::Resolved
+                && reference.table.as_deref() == Some("t")
+        }),
+        "expected qualified unknown column to stay as best-effort t.order_id, got {:?}",
+        analysis.projections[0].upstream
+    );
+    assert!(
+        analysis.projections[1].upstream.iter().any(|reference| {
+            reference.column == "amount" && reference.table.as_deref() == Some("t")
+        }),
+        "expected known t.amount to resolve, got {:?}",
+        analysis.projections[1].upstream
+    );
+}
+
+#[test]
+fn analyze_query_tolerates_partial_schema_for_join_conditions() {
+    let schema: ValidationSchema = serde_json::from_value(json!({
+        "tables": [
+            {
+                "name": "t",
+                "columns": [{"name": "order_id", "type": "INT"}]
+            },
+            {
+                "name": "u",
+                "columns": [{"name": "amount", "type": "INT"}]
+            }
+        ]
+    }))
+    .unwrap();
+
+    let analysis = analyze_query(
+        "SELECT a.order_id, b.amount FROM t a JOIN u b ON a.id = b.id",
+        AnalyzeQueryOptions {
+            dialect: DialectType::DuckDB,
+            schema: Some(schema),
+        },
+    )
+    .unwrap();
+
+    assert_eq!(analysis.projections.len(), 2);
+    assert!(
+        analysis.projections[0].upstream.iter().any(|reference| {
+            reference.column == "order_id"
+                && reference.source_alias.as_deref() == Some("a")
+                && reference.table.as_deref() == Some("t")
+        }),
+        "expected a.order_id to resolve, got {:?}",
+        analysis.projections[0].upstream
+    );
+    assert!(
+        analysis.projections[1].upstream.iter().any(|reference| {
+            reference.column == "amount"
+                && reference.source_alias.as_deref() == Some("b")
+                && reference.table.as_deref() == Some("u")
+        }),
+        "expected b.amount to resolve, got {:?}",
+        analysis.projections[1].upstream
+    );
+}
+
 #[test]
 fn analyze_query_resolves_same_select_alias_reference() {
     let analysis = analyze_query(

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql/tests/tsql_regression.rs

@@ -2,8 +2,8 @@
 
 use polyglot_sql::generator::{Generator, GeneratorConfig};
 use polyglot_sql::{
-    get_all_tables, parse, transpile, validate, Dialect, DialectType, Expression, ExpressionWalk,
-    Parser, TokenType,
+    generate, get_all_tables, parse, transpile, validate, Dialect, DialectType, Expression,
+    ExpressionWalk, Parser, TokenType,
 };
 
 fn pg_to_tsql(sql: &str) -> String {
@@ -72,6 +72,51 @@ fn tsql_hex_literals_parse_and_roundtrip() {
     }
 }
 
+#[test]
+fn tsql_datepart_dayofweek_generates_valid_tsql_datepart() {
+    let cases = [
+        ("WEEKDAY", "WEEKDAY"),
+        ("dw", "WEEKDAY"),
+        ("DAYOFWEEK", "WEEKDAY"),
+        ("isowk", "ISO_WEEK"),
+        ("WEEKISO", "ISO_WEEK"),
+        ("tz", "TZOFFSET"),
+        ("TIMEZONE_MINUTE", "TZOFFSET"),
+    ];
+
+    for dialect in [DialectType::TSQL, DialectType::Fabric] {
+        for (input, expected) in cases {
+            let sql = format!("SELECT DATEPART({input}, o.order_date) AS dow FROM orders o");
+            let ast = parse(&sql, dialect)
+                .unwrap_or_else(|error| panic!("{dialect:?} DATEPART should parse: {error}"));
+            assert_eq!(ast.len(), 1);
+
+            let generated = generate(&ast[0], dialect)
+                .unwrap_or_else(|error| panic!("{dialect:?} DATEPART should generate: {error}"));
+
+            assert_eq!(
+                generated,
+                format!("SELECT DATEPART({expected}, o.order_date) AS dow FROM orders AS o"),
+                "failed for {dialect:?} DATEPART({input}, ...)"
+            );
+        }
+    }
+}
+
+#[test]
+fn tsql_datepart_dayofweek_transpiles_to_valid_tsql_datepart() {
+    let sql = "SELECT DATEPART(WEEKDAY, o.order_date) AS dow FROM orders o";
+
+    assert_eq!(
+        transpile(sql, DialectType::TSQL, DialectType::TSQL).expect("TSQL identity transpile"),
+        vec!["SELECT DATEPART(WEEKDAY, o.order_date) AS dow FROM orders AS o"]
+    );
+    assert_eq!(
+        transpile(sql, DialectType::TSQL, DialectType::Fabric).expect("TSQL to Fabric transpile"),
+        vec!["SELECT DATEPART(WEEKDAY, o.order_date) AS dow FROM orders AS o"]
+    );
+}
+
 // ---------------------------------------------------------------------------
 // T-SQL SET options
 // ---------------------------------------------------------------------------

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql-python/tests/test_lineage.py

@@ -113,6 +113,23 @@ def test_lineage_with_schema_resolves_ambiguous_column():
     assert any(name == "u.id" for name in names), f"expected u.id in lineage tree, got: {names}"
 
 
+def test_lineage_with_schema_tolerates_partial_schema():
+    schema = {
+        "tables": [
+            {
+                "name": "t",
+                "columns": [{"name": "amount", "type": "INT"}],
+            }
+        ]
+    }
+    result = polyglot_sql.lineage_with_schema(
+        "amount", "SELECT order_id, amount FROM t", schema, dialect="duckdb"
+    )
+
+    names = collect_names(result)
+    assert "t.amount" in names
+
+
 def test_bigquery_unnest_lineage_marks_virtual_source():
     sql = """
 SELECT date_val AS week_start

{polyglot_sql-0.5.9 → polyglot_sql-0.5.11}/crates/polyglot-sql-python/tests/test_query_analysis.py

@@ -35,6 +35,36 @@ def test_analyze_query_accepts_schema_options():
     assert result["projections"][0]["castType"] == "TEXT"
 
 
+def test_analyze_query_tolerates_partial_schema():
+    schema = {
+        "tables": [
+            {
+                "name": "t",
+                "columns": [{"name": "amount", "type": "INT"}],
+            }
+        ]
+    }
+    result = polyglot_sql.analyze_query(
+        "SELECT order_id, amount FROM t",
+        {"schema": schema, "dialect": "duckdb"},
+    )
+
+    assert [projection["name"] for projection in result["projections"]] == [
+        "order_id",
+        "amount",
+    ]
+    assert any(
+        reference["column"] == "order_id"
+        and reference["table"] == "t"
+        and reference["confidence"] == "resolved"
+        for reference in result["projections"][0]["upstream"]
+    )
+    assert any(
+        reference["column"] == "amount" and reference["table"] == "t"
+        for reference in result["projections"][1]["upstream"]
+    )
+
+
 def test_analyze_query_reports_transform_function_arguments():
     schema = {
         "tables": [