polyglot-sql 0.5.1__tar.gz → 0.5.2__tar.gz

{polyglot_sql-0.5.1 → polyglot_sql-0.5.2}/Cargo.lock

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

{polyglot_sql-0.5.1 → polyglot_sql-0.5.2}/Cargo.toml

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

{polyglot_sql-0.5.1 → polyglot_sql-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.5.1
+Version: 0.5.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -125,22 +125,30 @@ emission are intentionally out of scope.
 
 ```python
 analysis = polyglot_sql.analyze_query(
-    "SELECT CAST(total AS TEXT) AS total_text FROM orders",
+    "SELECT SUM(o.amount) AS total FROM orders AS o",
     {
         "dialect": "generic",
         "schema": {
             "tables": [
                 {
                     "name": "orders",
-                    "columns": [{"name": "total", "type": "INT"}],
+                    "columns": [{"name": "amount", "type": "DECIMAL(10,2)"}],
                 }
             ]
         },
     },
 )
-print(analysis["projections"][0]["transformKind"])  # "cast"
+print(analysis["projections"][0]["transformKind"])  # "aggregation"
+print(analysis["projections"][0]["typeHint"])       # "DECIMAL(10, 2)"
+print(analysis["baseTables"][0]["name"])            # "orders"
 ```
 
+`analysis["relations"]` reports sources visible in the analyzed scope.
+`analysis["baseTables"]` reports deduplicated physical table dependencies across
+nested CTEs, derived tables, subqueries, and set-operation branches. Validation
+uses broad type families, while query analysis preserves parseable detailed
+schema type strings for projection `typeHint` values.
+
 ## API Reference
 
 All functions are exported from `polyglot_sql`.

{polyglot_sql-0.5.1/crates/polyglot-sql-python → polyglot_sql-0.5.2}/README.md

@@ -98,22 +98,30 @@ emission are intentionally out of scope.
 
 ```python
 analysis = polyglot_sql.analyze_query(
-    "SELECT CAST(total AS TEXT) AS total_text FROM orders",
+    "SELECT SUM(o.amount) AS total FROM orders AS o",
     {
         "dialect": "generic",
         "schema": {
             "tables": [
                 {
                     "name": "orders",
-                    "columns": [{"name": "total", "type": "INT"}],
+                    "columns": [{"name": "amount", "type": "DECIMAL(10,2)"}],
                 }
             ]
         },
     },
 )
-print(analysis["projections"][0]["transformKind"])  # "cast"
+print(analysis["projections"][0]["transformKind"])  # "aggregation"
+print(analysis["projections"][0]["typeHint"])       # "DECIMAL(10, 2)"
+print(analysis["baseTables"][0]["name"])            # "orders"
 ```
 
+`analysis["relations"]` reports sources visible in the analyzed scope.
+`analysis["baseTables"]` reports deduplicated physical table dependencies across
+nested CTEs, derived tables, subqueries, and set-operation branches. Validation
+uses broad type families, while query analysis preserves parseable detailed
+schema type strings for projection `typeHint` values.
+
 ## API Reference
 
 All functions are exported from `polyglot_sql`.

{polyglot_sql-0.5.1 → polyglot_sql-0.5.2}/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.1", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.5.2", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.5.1 → polyglot_sql-0.5.2}/crates/polyglot-sql/README.md

@@ -313,21 +313,35 @@ Schema-aware validation emits stable codes such as:
 ### Compact Query Analysis
 
 Use `analyze_query` when you need high-level facts without consuming the full AST
-or full lineage graph:
+or full lineage graph. `relations` reports sources visible in the analyzed
+scope, while `base_tables` reports deduplicated physical table dependencies
+across CTEs, derived tables, subqueries, and set-operation branches. When a
+`ValidationSchema` is supplied, detailed type strings such as `DECIMAL(10,2)`
+are preserved in projection `type_hint` values when parseable.
 
 ```rust
 use polyglot_sql::{analyze_query, AnalyzeQueryOptions, DialectType, QueryShape};
 
+let schema: polyglot_sql::ValidationSchema = serde_json::from_value(serde_json::json!({
+    "tables": [{
+        "name": "orders",
+        "columns": [{"name": "amount", "type": "DECIMAL(10,2)"}]
+    }]
+})).unwrap();
+
 let analysis = analyze_query(
-    "SELECT o.total AS total FROM orders o",
+    "SELECT SUM(o.amount) AS total FROM orders o",
     AnalyzeQueryOptions {
         dialect: DialectType::Generic,
-        schema: None,
+        schema: Some(schema),
     },
 ).unwrap();
 
 assert_eq!(analysis.shape, QueryShape::Select);
 assert_eq!(analysis.projections[0].name.as_deref(), Some("total"));
+assert_eq!(analysis.projections[0].transform_kind, polyglot_sql::TransformKind::Aggregation);
+assert_eq!(analysis.base_tables[0].name, "orders");
+assert_eq!(analysis.base_tables[0].alias.as_deref(), Some("o"));
 ```
 
 ### Tokenize

{polyglot_sql-0.5.1 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/lineage.rs

@@ -772,12 +772,32 @@ fn to_node_inner(
     apply_scope_context(&mut node, scope, source_name, reference_node_name);
 
     // 5. Star handling — add downstream for each source
-    if matches!(&select_expr, Expression::Star(_)) {
+    if let Expression::Star(star) = &select_expr {
+        let star_table = star
+            .table
+            .as_ref()
+            .map(|identifier| identifier.name.as_str());
         for (name, source_info) in &scope.sources {
+            if let Some(star_table) = star_table {
+                let table_matches = name.eq_ignore_ascii_case(star_table)
+                    || source_info
+                        .alias
+                        .as_deref()
+                        .is_some_and(|alias| alias.eq_ignore_ascii_case(star_table))
+                    || matches!(
+                        &source_info.expression,
+                        Expression::Table(table_ref)
+                            if table_name_from_table_ref(table_ref).eq_ignore_ascii_case(star_table)
+                    );
+                if !table_matches {
+                    continue;
+                }
+            }
+
             let mut child = LineageNode::new(
                 format!("{}.*", name),
                 Expression::Star(crate::expressions::Star {
-                    table: None,
+                    table: star.table.clone(),
                     except: None,
                     replace: None,
                     rename: None,

{polyglot_sql-0.5.1 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/optimizer/qualify_columns.rs

@@ -653,21 +653,23 @@ fn expand_stars(
 
     for expr in &select.expressions {
         match expr {
-            Expression::Star(_) => {
+            Expression::Star(star) => {
                 has_star = true;
-                for source_name in &ordered_sources {
-                    if let Ok(columns) = resolver.get_source_columns(source_name) {
+                if let Some(table) = &star.table {
+                    let table_name = &table.name;
+                    if !ordered_sources.contains(table_name) {
+                        return Err(QualifyColumnsError::UnknownTable(table_name.clone()));
+                    }
+                    if let Ok(columns) = resolver.get_source_columns(table_name) {
                         if columns.contains(&"*".to_string()) || columns.is_empty() {
                             return Ok(());
                         }
                         for col_name in &columns {
                             if coalesced_columns.contains(col_name) {
-                                // Already emitted as COALESCE, skip
                                 continue;
                             }
                             if let Some(tables) = column_tables.get(col_name) {
-                                if tables.contains(source_name) {
-                                    // Emit COALESCE and mark as coalesced
+                                if tables.contains(table_name) {
                                     coalesced_columns.insert(col_name.clone());
                                     let coalesce = make_coalesce(col_name, tables);
                                     new_selections.push(Expression::Alias(Box::new(Alias {
@@ -684,7 +686,41 @@ fn expand_stars(
                                 }
                             }
                             new_selections
-                                .push(create_qualified_column(col_name, Some(source_name)));
+                                .push(create_qualified_column(col_name, Some(table_name)));
+                        }
+                    }
+                } else {
+                    for source_name in &ordered_sources {
+                        if let Ok(columns) = resolver.get_source_columns(source_name) {
+                            if columns.contains(&"*".to_string()) || columns.is_empty() {
+                                return Ok(());
+                            }
+                            for col_name in &columns {
+                                if coalesced_columns.contains(col_name) {
+                                    // Already emitted as COALESCE, skip
+                                    continue;
+                                }
+                                if let Some(tables) = column_tables.get(col_name) {
+                                    if tables.contains(source_name) {
+                                        // Emit COALESCE and mark as coalesced
+                                        coalesced_columns.insert(col_name.clone());
+                                        let coalesce = make_coalesce(col_name, tables);
+                                        new_selections.push(Expression::Alias(Box::new(Alias {
+                                            this: coalesce,
+                                            alias: Identifier::new(col_name),
+                                            column_aliases: vec![],
+                                            alias_explicit_as: false,
+                                            alias_keyword: None,
+                                            pre_alias_comments: vec![],
+                                            trailing_comments: vec![],
+                                            inferred_type: None,
+                                        })));
+                                        continue;
+                                    }
+                                }
+                                new_selections
+                                    .push(create_qualified_column(col_name, Some(source_name)));
+                            }
                         }
                     }
                 }

{polyglot_sql-0.5.1 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/query_analysis.rs

@@ -11,11 +11,11 @@ use crate::expressions::{DataType, Expression, TableRef, With};
 use crate::lineage::{lineage_by_index_from_expression, LineageNode};
 use crate::optimizer::annotate_types::annotate_types;
 use crate::optimizer::qualify_columns::{qualify_columns, QualifyColumnsOptions};
-use crate::schema::Schema;
+use crate::schema::{MappingSchema, Schema};
 use crate::scope::{build_scope, Scope, SourceInfo, SourceKind};
 use crate::traversal::{contains_aggregate, ExpressionWalk};
 use crate::validation::{mapping_schema_from_validation_schema, ValidationSchema};
-use crate::{parse_one, Error, Result};
+use crate::{parse_data_type, parse_one, Error, Result};
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 
@@ -37,6 +37,7 @@ pub struct QueryAnalysis {
     pub ctes: Vec<String>,
     pub projections: Vec<ProjectionFact>,
     pub relations: Vec<RelationFact>,
+    pub base_tables: Vec<RelationFact>,
     pub set_operations: Vec<SetOperationFact>,
 }
 
@@ -134,7 +135,7 @@ pub fn analyze_query(sql: &str, options: AnalyzeQueryOptions) -> Result<QueryAna
     let mapping_schema = options
         .schema
         .as_ref()
-        .map(mapping_schema_from_validation_schema);
+        .map(|schema| analysis_mapping_schema(schema, options.dialect));
 
     if let Some(schema) = mapping_schema.as_ref() {
         let qualify_options = QualifyColumnsOptions::new().with_dialect(options.dialect);
@@ -142,12 +143,31 @@ pub fn analyze_query(sql: &str, options: AnalyzeQueryOptions) -> Result<QueryAna
             .map_err(|e| Error::internal(format!("query analysis qualification failed: {e}")))?;
     }
 
+    let annotation_schema = mapping_schema.as_ref().map(|schema| {
+        let mut alias_schema = schema.clone();
+        add_scope_aliases_to_schema(
+            &build_scope(&expression),
+            schema,
+            &mut alias_schema,
+            options.dialect,
+        );
+        alias_schema
+    });
+
     annotate_types(
         &mut expression,
-        mapping_schema.as_ref().map(|s| s as _),
+        annotation_schema
+            .as_ref()
+            .map(|schema| schema as &dyn Schema),
         Some(options.dialect),
     );
-    crate::lineage::expand_cte_stars(&mut expression, mapping_schema.as_ref().map(|s| s as _));
+    crate::lineage::expand_cte_stars(
+        &mut expression,
+        annotation_schema
+            .as_ref()
+            .or(mapping_schema.as_ref())
+            .map(|schema| schema as &dyn Schema),
+    );
 
     let scope = build_scope(&expression);
     let shape = if is_set_operation(&expression) {
@@ -161,10 +181,106 @@ pub fn analyze_query(sql: &str, options: AnalyzeQueryOptions) -> Result<QueryAna
         ctes: collect_cte_names(&expression),
         projections: projection_facts_for_query(&expression, &scope, options.dialect),
         relations: relation_facts(&scope, mapping_schema.as_ref()),
+        base_tables: base_table_facts(&scope, mapping_schema.as_ref()),
         set_operations: set_operation_facts(&expression, &scope, options.dialect),
     })
 }
 
+fn analysis_mapping_schema(schema: &ValidationSchema, dialect: DialectType) -> MappingSchema {
+    let broad_schema = mapping_schema_from_validation_schema(schema);
+    let mut mapping_schema = MappingSchema::with_dialect(dialect);
+
+    for table in &schema.tables {
+        let table_names = validation_table_names(table);
+        if table_names.is_empty() {
+            continue;
+        }
+
+        let fallback_table = table_names[0].as_str();
+        let columns: Vec<(String, DataType)> = table
+            .columns
+            .iter()
+            .map(|column| {
+                let data_type = parse_analysis_data_type(&column.data_type, dialect)
+                    .unwrap_or_else(|| {
+                        broad_schema
+                            .get_column_type(fallback_table, &column.name)
+                            .unwrap_or(DataType::Unknown)
+                    });
+                (column.name.to_ascii_lowercase(), data_type)
+            })
+            .collect();
+
+        for table_name in table_names {
+            let _ = mapping_schema.add_table(&table_name, &columns, Some(dialect));
+        }
+    }
+
+    mapping_schema
+}
+
+fn validation_table_names(table: &crate::validation::SchemaTable) -> Vec<String> {
+    let mut names = Vec::new();
+
+    names.push(table.name.to_ascii_lowercase());
+    if let Some(schema_name) = &table.schema {
+        names.push(format!(
+            "{}.{}",
+            schema_name.to_ascii_lowercase(),
+            table.name.to_ascii_lowercase()
+        ));
+    }
+    for alias in &table.aliases {
+        names.push(alias.to_ascii_lowercase());
+    }
+
+    names.sort();
+    names.dedup();
+    names
+}
+
+fn parse_analysis_data_type(data_type: &str, dialect: DialectType) -> Option<DataType> {
+    let trimmed = data_type.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+    parse_data_type(trimmed, dialect).ok()
+}
+
+fn add_scope_aliases_to_schema(
+    scope: &Scope,
+    source_schema: &MappingSchema,
+    target_schema: &mut MappingSchema,
+    dialect: DialectType,
+) {
+    for child_scope in scope.traverse() {
+        for (source_name, source) in &child_scope.sources {
+            if source.kind != SourceKind::Table {
+                continue;
+            }
+            if let Some(table_name) = source_table_name(source) {
+                if source_name == &table_name {
+                    continue;
+                }
+                if let Ok(column_names) = source_schema.column_names(&table_name) {
+                    let columns: Vec<(String, DataType)> = column_names
+                        .iter()
+                        .map(|column| {
+                            (
+                                column.clone(),
+                                source_schema
+                                    .get_column_type(&table_name, column)
+                                    .unwrap_or(DataType::Unknown),
+                            )
+                        })
+                        .collect();
+                    let _ = target_schema.add_table(source_name, &columns, Some(dialect));
+                }
+            }
+        }
+    }
+}
+
 fn effective_query(expression: Expression) -> Expression {
     match expression {
         Expression::Prepare(prepare) => prepare.statement,
@@ -621,6 +737,38 @@ fn collect_relation_facts(
     }
 }
 
+fn base_table_facts(
+    scope: &Scope,
+    mapping_schema: Option<&crate::schema::MappingSchema>,
+) -> Vec<RelationFact> {
+    let mut relations = Vec::new();
+    let mut seen = HashSet::new();
+
+    for child_scope in scope.traverse() {
+        for source in child_scope.sources.values() {
+            if source.kind != SourceKind::Table {
+                continue;
+            }
+
+            let Some(table_name) = source_table_name(source) else {
+                continue;
+            };
+
+            if seen.insert(table_name.clone()) {
+                relations.push(RelationFact {
+                    name: table_name,
+                    alias: source.alias.clone().or_else(|| source_alias(source)),
+                    kind: SourceKind::Table,
+                    columns: source_columns(source, mapping_schema),
+                });
+            }
+        }
+    }
+
+    relations.sort_by(|left, right| left.name.cmp(&right.name));
+    relations
+}
+
 fn source_columns(
     source: &SourceInfo,
     mapping_schema: Option<&crate::schema::MappingSchema>,

{polyglot_sql-0.5.1 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/scope.rs

@@ -726,7 +726,11 @@ fn add_table_to_scope(expr: &Expression, scope: &mut Scope) {
             if let Some(source) = cte_source {
                 scope.add_source_info(name, source.clone());
             } else {
-                scope.add_source(name, expr.clone(), false);
+                let mut source = SourceInfo::new(expr.clone(), false, SourceKind::Table);
+                if let Some(alias) = &table.alias {
+                    source = source.with_alias(alias.name.clone());
+                }
+                scope.add_source_info(name, source);
             }
         }
         Expression::Subquery(subquery) => {

{polyglot_sql-0.5.1 → polyglot_sql-0.5.2}/crates/polyglot-sql/src/traversal.rs

@@ -1098,9 +1098,22 @@ pub fn is_select(expr: &Expression) -> bool {
     matches!(expr, Expression::Select(_))
 }
 
-/// Returns `true` if `expr` is an aggregate function ([`Expression::AggregateFunction`]).
+/// Returns `true` if `expr` is an aggregate function.
 pub fn is_aggregate(expr: &Expression) -> bool {
-    matches!(expr, Expression::AggregateFunction(_))
+    matches!(
+        expr,
+        Expression::AggregateFunction(_)
+            | Expression::Count(_)
+            | Expression::Sum(_)
+            | Expression::Avg(_)
+            | Expression::Min(_)
+            | Expression::Max(_)
+            | Expression::GroupConcat(_)
+            | Expression::StringAgg(_)
+            | Expression::ListAgg(_)
+            | Expression::CountIf(_)
+            | Expression::SumIf(_)
+    )
 }
 
 /// Returns `true` if `expr` is a window function ([`Expression::WindowFunction`]).