sqlbuild 0.89.1__tar.gz → 0.90.1__tar.gz

{sqlbuild-0.89.1 → sqlbuild-0.90.1}/Cargo.lock

@@ -597,7 +597,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.89.1"
+version = "0.90.1"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.89.1 → sqlbuild-0.90.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.89.1
+Version: 0.90.1
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: polyglot-sql==0.9.2

{sqlbuild-0.89.1 → sqlbuild-0.90.1}/crates/sqlbuild-kata-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-kata-native"
-version = "0.89.1"
+version = "0.90.1"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.89.1 → sqlbuild-0.90.1}/crates/sqlbuild-kata-native/src/bindings/_helpers/functions.rs

@@ -34,6 +34,24 @@ fn format_sql_json(py: Python<'_>, request_json: &str) -> PyResult<String> {
         .map_err(value_error)
 }
 
+#[pyfunction(name = "validate_sql_with_schema_json")]
+fn schema_validation_json(py: Python<'_>, request_json: &str) -> PyResult<String> {
+    py.detach(|| crate::semantic_validation::validation_json(request_json))
+        .map_err(value_error)
+}
+
+#[pyfunction(name = "validate_sql_with_schemas_json")]
+fn schema_validations_json(py: Python<'_>, request_json: &str) -> PyResult<String> {
+    py.detach(|| crate::semantic_validation::validations_json(request_json))
+        .map_err(value_error)
+}
+
+#[pyfunction]
+fn analyze_sql_uses_json(py: Python<'_>, request_json: &str) -> PyResult<String> {
+    py.detach(|| crate::semantic_usage::analyze_json(request_json))
+        .map_err(value_error)
+}
+
 #[pyfunction]
 fn load_config_json(project_dir: &str) -> PyResult<String> {
     load::load_config_json(std::path::Path::new(project_dir)).map_err(value_error)
@@ -80,6 +98,9 @@ pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(evaluate_json, module)?)?;
     module.add_function(wrap_pyfunction!(lint_sql_json, module)?)?;
     module.add_function(wrap_pyfunction!(format_sql_json, module)?)?;
+    module.add_function(wrap_pyfunction!(schema_validation_json, module)?)?;
+    module.add_function(wrap_pyfunction!(schema_validations_json, module)?)?;
+    module.add_function(wrap_pyfunction!(analyze_sql_uses_json, module)?)?;
     module.add_function(wrap_pyfunction!(load_config_json, module)?)?;
     module.add_function(wrap_pyfunction!(catalogue_json, module)?)?;
     module.add_function(wrap_pyfunction!(selected_codes_json, module)?)?;

{sqlbuild-0.89.1 → sqlbuild-0.90.1}/crates/sqlbuild-kata-native/src/lib.rs

@@ -7,4 +7,6 @@ mod engine;
 mod models;
 mod rules;
 mod scope_metadata;
+mod semantic_usage;
+mod semantic_validation;
 mod sql_lint;

sqlbuild-0.90.1/crates/sqlbuild-kata-native/src/semantic_usage/tests/test_semantic_usage.rs

@@ -0,0 +1,36 @@
+use crate::semantic_usage::analyze_json;
+use crate::semantic_usage::tests::test_types::SemanticUsageTestCase;
+
+#[test]
+fn given_filter_and_join_when_analyzing_then_returns_direct_contextual_uses() -> Result<(), String>
+{
+    let test_cases = [SemanticUsageTestCase {
+        description: "filter and join uses are complete",
+        request: r#"{
+            "sql":"SELECT o.id FROM orders o JOIN customers c ON o.customer_id = c.id WHERE o.active",
+            "dialect":"generic",
+            "schema":{"strict":true,"tables":[
+              {"name":"orders","columns":[{"name":"id","type":"INTEGER"},{"name":"customer_id","type":"INTEGER"},{"name":"active","type":"BOOLEAN"}]},
+              {"name":"customers","columns":[{"name":"id","type":"INTEGER"}]}
+            ]}
+          }"#,
+        expected_complete: true,
+    }];
+    for test_case in &test_cases {
+        let response = analyze_json(test_case.request)?;
+        let observed_complete = [
+            "\"context\":\"join_on\"",
+            "\"context\":\"where\"",
+            "\"column\":\"customer_id\"",
+            "\"column\":\"active\"",
+        ]
+        .iter()
+        .all(|expected| response.contains(expected));
+        assert_eq!(
+            observed_complete, test_case.expected_complete,
+            "{}",
+            test_case.description
+        );
+    }
+    Ok(())
+}

sqlbuild-0.90.1/crates/sqlbuild-kata-native/src/semantic_usage/tests/test_types.rs

@@ -0,0 +1,5 @@
+pub(crate) struct SemanticUsageTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) request: &'static str,
+    pub(crate) expected_complete: bool,
+}

sqlbuild-0.90.1/crates/sqlbuild-kata-native/src/semantic_usage/tests.rs

@@ -0,0 +1,4 @@
+#[path = "tests/test_semantic_usage.rs"]
+mod semantic_usage;
+#[path = "tests/test_types.rs"]
+mod test_types;

sqlbuild-0.90.1/crates/sqlbuild-kata-native/src/semantic_usage.rs

@@ -0,0 +1,245 @@
+//! On-demand direct non-projection column usage extraction.
+
+use polyglot_sql::{
+    Dialect, DialectType, Expression, ExpressionWalk, Resolver, SchemaValidationOptions,
+    ValidationSchema, build_scope, mapping_schema_from_validation_schema_with_dialect,
+    validate_with_schema,
+};
+use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+
+#[derive(Deserialize)]
+struct UsageRequest {
+    sql: String,
+    #[serde(default = "default_dialect")]
+    dialect: String,
+    schema: ValidationSchema,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct UsageResponse {
+    uses: Vec<UsageFact>,
+}
+
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct UsageFact {
+    context: String,
+    expression_sql: String,
+    source_name: String,
+    source_alias: Option<String>,
+    column: String,
+    confidence: String,
+    start: Option<usize>,
+    end: Option<usize>,
+    line: Option<usize>,
+    column_offset: Option<usize>,
+}
+
+struct UsageCollector<'a, 'b> {
+    scope: &'a polyglot_sql::Scope,
+    resolver: Resolver<'b>,
+}
+
+fn default_dialect() -> String {
+    "generic".to_string()
+}
+
+pub(crate) fn analyze_json(request_json: &str) -> Result<String, String> {
+    let request: UsageRequest =
+        serde_json::from_str(request_json).map_err(|error| error.to_string())?;
+    let dialect: DialectType = request.dialect.parse().map_err(|error| {
+        format!(
+            "unsupported Polyglot dialect '{}': {error}",
+            request.dialect
+        )
+    })?;
+    let validation = validate_with_schema(
+        &request.sql,
+        dialect,
+        &request.schema,
+        &SchemaValidationOptions {
+            check_references: true,
+            strict: Some(true),
+            ..SchemaValidationOptions::default()
+        },
+    );
+    if !validation.valid {
+        return serde_json::to_string(&UsageResponse { uses: Vec::new() })
+            .map_err(|error| error.to_string());
+    }
+    let statements = Dialect::get(dialect)
+        .parse(&request.sql)
+        .map_err(|error| error.to_string())?;
+    let schema = mapping_schema_from_validation_schema_with_dialect(&request.schema, dialect);
+    let mut uses: Vec<UsageFact> = Vec::new();
+    for statement in statements {
+        let scope = build_scope(&statement);
+        uses.extend(collect_scope(&scope, &schema));
+    }
+    let uses = dedupe(uses);
+    serde_json::to_string(&UsageResponse { uses }).map_err(|error| error.to_string())
+}
+
+fn collect_scope(
+    scope: &polyglot_sql::Scope,
+    schema: &polyglot_sql::MappingSchema,
+) -> Vec<UsageFact> {
+    let mut collector = UsageCollector {
+        scope,
+        resolver: Resolver::new(scope, schema, false),
+    };
+    let mut uses: Vec<UsageFact> = Vec::new();
+    if let Expression::Select(select) = &scope.expression {
+        for join in &select.joins {
+            if let Some(expression) = &join.on {
+                uses.extend(collector.collect_expression(expression, "join_on"));
+            }
+            if let Some(expression) = &join.match_condition {
+                uses.extend(collector.collect_expression(expression, "join_match_condition"));
+            }
+            for identifier in &join.using {
+                uses.extend(collector.collect_using(identifier.to_string()));
+            }
+        }
+        if let Some(clause) = &select.where_clause {
+            uses.extend(collector.collect_expression(&clause.this, "where"));
+        }
+        if let Some(clause) = &select.group_by {
+            for expression in &clause.expressions {
+                uses.extend(collector.collect_expression(expression, "group_by"));
+            }
+        }
+        if let Some(clause) = &select.having {
+            uses.extend(collector.collect_expression(&clause.this, "having"));
+        }
+        if let Some(clause) = &select.qualify {
+            uses.extend(collector.collect_expression(&clause.this, "qualify"));
+        }
+        if let Some(clause) = &select.order_by {
+            for ordered in &clause.expressions {
+                uses.extend(collector.collect_expression(&ordered.this, "order_by"));
+            }
+        }
+        for projection in &select.expressions {
+            for node in projection.dfs() {
+                if let Expression::WindowFunction(window) = node {
+                    for expression in &window.over.partition_by {
+                        uses.extend(
+                            collector.collect_expression(expression, "window_partition_by"),
+                        );
+                    }
+                    for ordered in &window.over.order_by {
+                        uses.extend(collector.collect_expression(&ordered.this, "window_order_by"));
+                    }
+                }
+            }
+        }
+    }
+    for child in scope
+        .cte_scopes
+        .iter()
+        .chain(scope.subquery_scopes.iter())
+        .chain(scope.derived_table_scopes.iter())
+        .chain(scope.udtf_scopes.iter())
+        .chain(scope.union_scopes.iter())
+    {
+        uses.extend(collect_scope(child, schema));
+    }
+    uses
+}
+
+impl UsageCollector<'_, '_> {
+    fn collect_expression(&mut self, expression: &Expression, context: &str) -> Vec<UsageFact> {
+        let mut uses: Vec<UsageFact> = Vec::new();
+        let expression_sql = expression.to_string();
+        for node in expression.dfs() {
+            let Expression::Column(column) = node else {
+                continue;
+            };
+            let column_name = column.name.to_string();
+            let alias = column
+                .table
+                .as_ref()
+                .map(ToString::to_string)
+                .or_else(|| self.resolver.get_table(&column_name));
+            let Some(source_alias) = alias else {
+                continue;
+            };
+            let Some(source) = self.scope.sources.get(&source_alias) else {
+                continue;
+            };
+            let source_name =
+                physical_source_name(&source.expression).unwrap_or(source_alias.clone());
+            let span = column.span;
+            uses.push(UsageFact {
+                context: context.to_string(),
+                expression_sql: expression_sql.clone(),
+                source_name,
+                source_alias: source.alias.clone().or(Some(source_alias)),
+                column: column_name,
+                confidence: "high".to_string(),
+                start: span.map(|value| value.start),
+                end: span.map(|value| value.end),
+                line: span.map(|value| value.line),
+                column_offset: span.map(|value| value.column),
+            });
+        }
+        uses
+    }
+
+    fn collect_using(&mut self, column_name: String) -> Vec<UsageFact> {
+        let mut uses: Vec<UsageFact> = Vec::new();
+        let source_names: Vec<String> = self.scope.sources.keys().cloned().collect();
+        for source_alias in source_names {
+            let Ok(columns) = self.resolver.get_source_columns(&source_alias) else {
+                continue;
+            };
+            if !columns.iter().any(|column| column == &column_name) {
+                continue;
+            }
+            let Some(source) = self.scope.sources.get(&source_alias) else {
+                continue;
+            };
+            uses.push(UsageFact {
+                context: "join_using".to_string(),
+                expression_sql: column_name.clone(),
+                source_name: physical_source_name(&source.expression)
+                    .unwrap_or(source_alias.clone()),
+                source_alias: source.alias.clone().or(Some(source_alias)),
+                column: column_name.clone(),
+                confidence: "high".to_string(),
+                start: None,
+                end: None,
+                line: None,
+                column_offset: None,
+            });
+        }
+        uses
+    }
+}
+
+fn physical_source_name(expression: &Expression) -> Option<String> {
+    match expression {
+        Expression::Table(table) => Some(table.name.to_string()),
+        _ => None,
+    }
+}
+
+fn dedupe(mut uses: Vec<UsageFact>) -> Vec<UsageFact> {
+    let mut seen: HashSet<(String, String, String, String, Option<usize>)> = HashSet::new();
+    uses.retain(|fact| {
+        seen.insert((
+            fact.context.clone(),
+            fact.expression_sql.clone(),
+            fact.source_name.clone(),
+            fact.column.clone(),
+            fact.start,
+        ))
+    });
+    uses
+}
+
+#[cfg(test)]
+mod tests;

sqlbuild-0.90.1/crates/sqlbuild-kata-native/src/semantic_validation/tests/test_semantic_validation.rs

@@ -0,0 +1,28 @@
+use crate::semantic_validation::tests::test_types::SemanticValidationTestCase;
+use crate::semantic_validation::validation_json;
+
+#[test]
+fn given_unknown_column_when_validating_then_returns_structured_error() -> Result<(), String> {
+    let test_cases = [SemanticValidationTestCase {
+        description: "unknown column returns stable native evidence",
+        request: r#"{
+              "sql":"SELECT missing FROM upstream",
+              "dialect":"generic",
+              "schema":{"strict":true,"tables":[{"name":"upstream","columns":[{"name":"id","type":"INTEGER"}]}]},
+              "options":{}
+          }"#,
+        expected_complete: true,
+    }];
+    for test_case in &test_cases {
+        let response = validation_json(test_case.request)?;
+        let observed_complete = ["\"valid\":false", "\"code\":\"E201\"", "missing"]
+            .iter()
+            .all(|expected| response.contains(expected));
+        assert_eq!(
+            observed_complete, test_case.expected_complete,
+            "{}",
+            test_case.description
+        );
+    }
+    Ok(())
+}

sqlbuild-0.90.1/crates/sqlbuild-kata-native/src/semantic_validation/tests/test_types.rs

@@ -0,0 +1,5 @@
+pub(crate) struct SemanticValidationTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) request: &'static str,
+    pub(crate) expected_complete: bool,
+}

sqlbuild-0.90.1/crates/sqlbuild-kata-native/src/semantic_validation/tests.rs

@@ -0,0 +1,4 @@
+#[path = "tests/test_semantic_validation.rs"]
+mod semantic_validation;
+#[path = "tests/test_types.rs"]
+mod test_types;

sqlbuild-0.90.1/crates/sqlbuild-kata-native/src/semantic_validation.rs

@@ -0,0 +1,175 @@
+//! Stable SQLBuild boundary around Polyglot schema-aware validation.
+
+use polyglot_sql::{
+    Dialect, DialectType, Expression, ExpressionWalk, Resolver, SchemaValidationOptions,
+    ValidationError, ValidationResult, ValidationSchema, build_scope,
+    mapping_schema_from_validation_schema_with_dialect, validate_with_schema,
+};
+use serde::Deserialize;
+
+const MINIMUM_USING_SOURCE_COUNT: usize = 2;
+
+#[derive(Deserialize)]
+struct ValidationRequest {
+    sql: String,
+    #[serde(default = "default_dialect")]
+    dialect: String,
+    schema: ValidationSchema,
+    #[serde(default)]
+    options: SchemaValidationOptions,
+}
+
+struct ClauseResolver<'a, 'b> {
+    scope: &'a polyglot_sql::Scope,
+    resolver: Resolver<'b>,
+}
+
+fn default_dialect() -> String {
+    "generic".to_string()
+}
+
+pub(crate) fn validation_json(request_json: &str) -> Result<String, String> {
+    let request: ValidationRequest =
+        serde_json::from_str(request_json).map_err(|error| error.to_string())?;
+    let result = validation_result(request)?;
+    serde_json::to_string(&result).map_err(|error| error.to_string())
+}
+
+pub(crate) fn validations_json(request_json: &str) -> Result<String, String> {
+    let requests: Vec<ValidationRequest> =
+        serde_json::from_str(request_json).map_err(|error| error.to_string())?;
+    let results: Result<Vec<ValidationResult>, String> =
+        requests.into_iter().map(validation_result).collect();
+    serde_json::to_string(&results?).map_err(|error| error.to_string())
+}
+
+fn validation_result(request: ValidationRequest) -> Result<ValidationResult, String> {
+    let dialect: DialectType = request.dialect.parse().map_err(|error| {
+        format!(
+            "unsupported Polyglot dialect '{}': {error}",
+            request.dialect
+        )
+    })?;
+    let mut result = validate_with_schema(
+        request.sql.as_str(),
+        dialect,
+        &request.schema,
+        &request.options,
+    );
+    if result.valid {
+        let statements = Dialect::get(dialect)
+            .parse(&request.sql)
+            .map_err(|error| error.to_string())?;
+        let schema = mapping_schema_from_validation_schema_with_dialect(&request.schema, dialect);
+        for statement in statements {
+            let scope = build_scope(&statement);
+            result
+                .errors
+                .extend(missing_clause_columns(&scope, &schema));
+        }
+        result.valid = !result
+            .errors
+            .iter()
+            .any(|error| error.severity == polyglot_sql::ValidationSeverity::Error);
+    }
+    Ok(result)
+}
+
+fn missing_clause_columns(
+    scope: &polyglot_sql::Scope,
+    schema: &polyglot_sql::MappingSchema,
+) -> Vec<ValidationError> {
+    let mut errors: Vec<ValidationError> = Vec::new();
+    let mut clause_resolver = ClauseResolver {
+        scope,
+        resolver: Resolver::new(scope, schema, false),
+    };
+    if let Expression::Select(select) = &scope.expression {
+        let projection_aliases: std::collections::HashSet<String> = select
+            .expressions
+            .iter()
+            .filter_map(|expression| match expression {
+                Expression::Alias(alias) => Some(alias.alias.to_string().to_lowercase()),
+                _ => None,
+            })
+            .collect();
+        if let Some(qualify) = &select.qualify {
+            for node in qualify.this.dfs() {
+                let Expression::Column(column) = node else {
+                    continue;
+                };
+                if column.table.is_none()
+                    && projection_aliases.contains(&column.name.to_string().to_lowercase())
+                {
+                    continue;
+                }
+                if !clause_resolver.column_exists(column) {
+                    let mut error = ValidationError::error(
+                        format!("Unknown column '{}' in QUALIFY", column.name),
+                        "E201",
+                    );
+                    if let Some(span) = column.span {
+                        error = error
+                            .with_location(span.line, span.column)
+                            .with_span(Some(span.start), Some(span.end));
+                    }
+                    errors.push(error);
+                }
+            }
+        }
+        for join in &select.joins {
+            for identifier in &join.using {
+                let column_name = identifier.to_string();
+                let mut matching_sources: usize = 0;
+                for source_name in scope.sources.keys() {
+                    if clause_resolver.source_has_column(source_name, &column_name) {
+                        matching_sources += 1;
+                    }
+                }
+                if matching_sources < MINIMUM_USING_SOURCE_COUNT {
+                    errors.push(ValidationError::error(
+                        format!("Unknown column '{column_name}' in JOIN USING"),
+                        "E201",
+                    ));
+                }
+            }
+        }
+    }
+    for child in scope
+        .cte_scopes
+        .iter()
+        .chain(scope.subquery_scopes.iter())
+        .chain(scope.derived_table_scopes.iter())
+        .chain(scope.udtf_scopes.iter())
+        .chain(scope.union_scopes.iter())
+    {
+        errors.extend(missing_clause_columns(child, schema));
+    }
+    errors
+}
+
+impl ClauseResolver<'_, '_> {
+    fn column_exists(&mut self, column: &polyglot_sql::expressions::Column) -> bool {
+        let column_name = column.name.to_string();
+        if let Some(table) = &column.table {
+            return self.source_has_column(&table.to_string(), &column_name);
+        }
+        let source_names: Vec<String> = self.scope.sources.keys().cloned().collect();
+        for source_name in source_names {
+            if self.source_has_column(&source_name, &column_name) {
+                return true;
+            }
+        }
+        false
+    }
+
+    fn source_has_column(&mut self, source_name: &str, column_name: &str) -> bool {
+        let Ok(columns) = self.resolver.get_source_columns(source_name) else {
+            return false;
+        };
+        columns.iter().any(|name| name == column_name)
+    }
+}
+
+#[cfg(test)]
+mod tests;

{sqlbuild-0.89.1 → sqlbuild-0.90.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.89.1"
+version = "0.90.1"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.89.1 → sqlbuild-0.90.1}/src/sqlbuild/adapter/type_system/_helpers/type_normalization.py

@@ -71,12 +71,10 @@ def types_equal(*, left: str, right: str, dialect: TypeDialect | str | None) ->
 def _normalize_with_polyglot(
     *, type_sql: str, dialect: TypeDialect | str | None
 ) -> NormalizedType | None:
-    polyglot_module: Any | None = import_polyglot()
-    if polyglot_module is None:
-        return None
+    polyglot_module: Any = import_polyglot()
     try:
         parsed: Any = polyglot_module.parse_data_type(type_sql, dialect=dialect or "generic")
-    except Exception as error:
+    except polyglot_module.PolyglotError as error:
         log_debug_event(
             logger=_DEBUG_LOGGER,
             message="type normalization polyglot parse failed; falling back",

{sqlbuild-0.89.1 → sqlbuild-0.90.1}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -25,12 +25,14 @@ from sqlbuild.cli.commands.models import (
     CloneCommandRequest,
     CompileCommandRequest,
     CompileProfileFlags,
+    ContractCommandRequest,
     CostCommandRequest,
     DbtInitCommandRequest,
     DiffCommandRequest,
     FreshnessCommandRequest,
     JanitorCommandRequest,
     KataCommandRequest,
+    LineageCommandRequest,
     LoadCommandRequest,
     PlanCommandRequest,
     PlaygroundCommandRequest,
@@ -57,6 +59,25 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
     effective_project_dir: Path = project_dir if project_dir is not None else Path.cwd()
     selector_inputs: SelectorInputs = read_selector_file_inputs(args.select_file)
     select: tuple[str, ...] = (*tuple(args.select), *selector_inputs.selectors)
+    if args.command == CliCommand.CONTRACT:
+        if handlers.run_contract is None:
+            raise CliUserError("contract command handler is unavailable", code="C470")
+        if args.contract_command is None or args.contract_from is None:
+            raise CliUserError("contract requires an action and --from target", code="C474")
+        return handlers.run_contract(
+            ContractCommandRequest(
+                action=args.contract_command,
+                from_target=args.contract_from,
+                project_dir=project_dir,
+                select=select,
+                exclude=tuple(args.exclude),
+                write=args.contract_write,
+                overwrite=args.overwrite,
+                json_output=args.json,
+                no_color=args.no_color,
+                cli_vars=args.vars,
+            )
+        )
     if args.command == CliCommand.COMPILE:
         return handlers.run_compile(
             CompileCommandRequest(
@@ -296,16 +317,19 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
         )
     if args.command == CliCommand.LINEAGE:
         return handlers.run_lineage(
-            project_dir=project_dir,
-            no_sql_validation=args.no_sql_validation,
-            target=args.lineage_target,
-            output_format=args.lineage_format,
-            direction=args.lineage_direction,
-            depth=args.lineage_depth,
-            select=select,
-            exclude=tuple(args.exclude),
-            lineage_mode=ColumnLineageMode(args.lineage_mode),
-            cli_vars=args.vars,
+            LineageCommandRequest(
+                project_dir=project_dir,
+                no_sql_validation=args.no_sql_validation,
+                target=args.lineage_target,
+                output_format=args.lineage_format,
+                direction=args.lineage_direction,
+                depth=args.lineage_depth,
+                select=select,
+                exclude=tuple(args.exclude),
+                lineage_mode=ColumnLineageMode(args.lineage_mode),
+                include_uses=args.lineage_include_uses,
+                cli_vars=args.vars,
+            )
         )
     if args.command == CliCommand.CLONE:
         if args.from_target is None: