sqlbuild 0.105.0__tar.gz → 0.106.1__tar.gz

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/Cargo.lock

@@ -529,7 +529,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.105.0"
+version = "0.106.1"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.105.0
+Version: 0.106.1
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.105.0"
+version = "0.106.1"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/crates/sqlbuild-rules-native/src/engine/tests/test_evaluation.rs

@@ -544,6 +544,160 @@ fn given_enforced_contract_outputs_when_evaluating_explicit_type_rule_then_retur
     Ok(())
 }
 
+#[test]
+fn given_contract_name_type_options_when_evaluating_then_accepts_configured_interfaces()
+-> Result<(), String> {
+    let project_dir = TempDir::new().map_err(|error| error.to_string())?;
+    let test_cases = [
+        test_types::ContractNameTypeOptionsTestCase {
+            description: "configured compatibility types are accepted",
+            config: json!({
+                "select": ["SQBRCONTRACT102", "SQBRCONTRACT103", "SQBRCONTRACT104"],
+                "rule_options": {
+                    "SQBRCONTRACT102": {"allow_numeric_indicators": true},
+                    "SQBRCONTRACT103": {
+                        "allow_date_for_at": true,
+                        "allow_numeric_epoch": true,
+                        "allow_encoded_values": true
+                    },
+                    "SQBRCONTRACT104": {
+                        "allow_timestamps": true,
+                        "allow_encoded_values": true
+                    }
+                },
+                "cache": {"enabled": false}
+            }),
+            expected_fault_codes: &[],
+        },
+        test_types::ContractNameTypeOptionsTestCase {
+            description: "compatibility types remain findings by default",
+            config: json!({
+                "select": ["SQBRCONTRACT102", "SQBRCONTRACT103", "SQBRCONTRACT104"],
+                "cache": {"enabled": false}
+            }),
+            expected_fault_codes: &[
+                "SQBRCONTRACT102",
+                "SQBRCONTRACT103",
+                "SQBRCONTRACT103",
+                "SQBRCONTRACT103",
+                "SQBRCONTRACT104",
+                "SQBRCONTRACT104",
+            ],
+        },
+    ];
+
+    for test_case in test_cases {
+        let mut request: Value =
+            serde_json::from_str(&helpers::request(&project_dir, &test_case.config))
+                .map_err(|error| error.to_string())?;
+        request["models"][0]["query_sql"] = json!(
+            "SELECT is_ready, first_seen_at, source_timestamp, opaque_ts, raw_date, observed_date FROM orders"
+        );
+        request["models"][0]["columns"] = json!([
+            {"name": "is_ready", "type": "INTEGER"},
+            {"name": "first_seen_at", "type": "DATE"},
+            {"name": "source_timestamp", "type": "NUMBER(38,0)"},
+            {"name": "opaque_ts", "type": "VARIANT"},
+            {"name": "raw_date", "type": "VARCHAR"},
+            {"name": "observed_date", "type": "TIMESTAMP_NTZ"}
+        ]);
+
+        let result: Value = serde_json::from_str(&evaluate_json(&request.to_string())?)
+            .map_err(|error| error.to_string())?;
+        let fault_codes: Vec<&str> = result["faults"]
+            .as_array()
+            .into_iter()
+            .flatten()
+            .filter_map(|fault| fault["code"].as_str())
+            .collect();
+        assert_eq!(
+            fault_codes, test_case.expected_fault_codes,
+            "{}",
+            test_case.description
+        );
+    }
+    Ok(())
+}
+
+#[test]
+fn given_numeric_comparisons_when_evaluating_named_decisions_then_only_authored_decisions_fault()
+-> Result<(), String> {
+    let project_dir = TempDir::new().map_err(|error| error.to_string())?;
+    let test_cases = [
+        test_types::NumericDecisionTestCase {
+            description: "authored threshold is a named decision finding",
+            query_sql: "SELECT amount FROM orders WHERE amount > 5",
+            authored_sql: "SELECT amount FROM orders WHERE amount > 5",
+            expected_fault_count: 1,
+        },
+        test_types::NumericDecisionTestCase {
+            description: "expanded named constant is not an authored literal finding",
+            query_sql: "SELECT amount FROM orders WHERE amount > 5",
+            authored_sql: "SELECT amount FROM orders WHERE amount > @const(\"_minimum_amount\")",
+            expected_fault_count: 0,
+        },
+        test_types::NumericDecisionTestCase {
+            description: "numeric comparison shown only in a comment is not an authored finding",
+            query_sql: "SELECT amount FROM orders WHERE amount > 5",
+            authored_sql: concat!(
+                "-- The expanded predicate is amount > 5.\n",
+                "SELECT amount FROM orders WHERE amount > @const(\"_minimum_amount\")"
+            ),
+            expected_fault_count: 0,
+        },
+        test_types::NumericDecisionTestCase {
+            description: "fixed output bucket suffix makes equality structural",
+            query_sql: concat!(
+                "SELECT MAX(CASE WHEN offset_seconds = 30 THEN amount END) AS amount_30 ",
+                "FROM orders"
+            ),
+            authored_sql: concat!(
+                "SELECT MAX(CASE WHEN offset_seconds = 30 THEN amount END) AS amount_30 ",
+                "FROM orders"
+            ),
+            expected_fault_count: 0,
+        },
+        test_types::NumericDecisionTestCase {
+            description: "output suffix does not exempt a threshold comparison",
+            query_sql: ("SELECT CASE WHEN amount > 30 THEN 'large' END AS amount_30 FROM orders"),
+            authored_sql: ("SELECT CASE WHEN amount > 30 THEN 'large' END AS amount_30 FROM orders"),
+            expected_fault_count: 1,
+        },
+        test_types::NumericDecisionTestCase {
+            description: "nested comparison reports only its leaf decision",
+            query_sql: ("SELECT CASE WHEN amount > 5 THEN status END = 'ready' AS selected FROM orders"),
+            authored_sql: ("SELECT CASE WHEN amount > 5 THEN status END = 'ready' AS selected FROM orders"),
+            expected_fault_count: 1,
+        },
+    ];
+
+    for test_case in test_cases {
+        let mut request: Value = serde_json::from_str(&helpers::request(
+            &project_dir,
+            &json!({
+                "select": ["SQBRDECLARATION102"],
+                "cache": {"enabled": false}
+            }),
+        ))
+        .map_err(|error| error.to_string())?;
+        request["models"][0]["query_sql"] = json!(test_case.query_sql);
+        request["models"][0]["authored_sql"] = json!(test_case.authored_sql);
+
+        let result: Value = serde_json::from_str(&evaluate_json(&request.to_string())?)
+            .map_err(|error| error.to_string())?;
+        let faults = result["faults"]
+            .as_array()
+            .ok_or_else(|| "faults must be an array".to_string())?;
+        assert_eq!(
+            faults.len(),
+            test_case.expected_fault_count,
+            "{}",
+            test_case.description
+        );
+    }
+    Ok(())
+}
+
 #[test]
 fn given_snowflake_parser_extensions_when_normalizing_then_preserves_source_positions() {
     let test_cases = [test_types::NormalizationTestCase {

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/crates/sqlbuild-rules-native/src/engine/tests/test_types.rs

@@ -29,6 +29,19 @@ pub(crate) struct ExplicitOutputTypeTestCase {
     pub(crate) expected_message_fragment: &'static str,
 }
 
+pub(crate) struct ContractNameTypeOptionsTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) config: Value,
+    pub(crate) expected_fault_codes: &'static [&'static str],
+}
+
+pub(crate) struct NumericDecisionTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) query_sql: &'static str,
+    pub(crate) authored_sql: &'static str,
+    pub(crate) expected_fault_count: usize,
+}
+
 pub(crate) struct TypedContractColumnTestCase {
     pub(crate) description: &'static str,
     pub(crate) contract: &'static str,

sqlbuild-0.106.1/crates/sqlbuild-rules-native/src/rules/_helpers/contract_name_types.rs

@@ -0,0 +1,91 @@
+use crate::constants::{BOOLEAN_TYPE, DATE_TYPE, TIMESTAMP_TYPE};
+use crate::models::{Column, RulesConfig};
+
+const BOOLEAN_COLUMN_RULE: &str = "SQBRCONTRACT102";
+const TIMESTAMP_COLUMN_RULE: &str = "SQBRCONTRACT103";
+const DATE_COLUMN_RULE: &str = "SQBRCONTRACT104";
+
+pub(crate) fn finding(column: &Column, config: &RulesConfig) -> Option<(&'static str, String)> {
+    let data_type = column.data_type.to_ascii_uppercase();
+    if column.name.starts_with("is_")
+        || column.name.starts_with("has_")
+        || column.name.starts_with("can_")
+    {
+        let allowed_numeric =
+            rule_option_enabled(config, BOOLEAN_COLUMN_RULE, "allow_numeric_indicators")
+                && numeric_type(&data_type);
+        return (data_type != BOOLEAN_TYPE && !allowed_numeric).then(|| {
+            (
+                BOOLEAN_COLUMN_RULE,
+                format!(
+                    "column {:?} implies BOOLEAN but is typed {data_type}",
+                    column.name
+                ),
+            )
+        });
+    }
+    if column.name.ends_with("_at")
+        || column.name.ends_with("_ts")
+        || column.name.ends_with("_timestamp")
+    {
+        let allowed_date = column.name.ends_with("_at")
+            && data_type == DATE_TYPE
+            && rule_option_enabled(config, TIMESTAMP_COLUMN_RULE, "allow_date_for_at");
+        let allowed_epoch = numeric_type(&data_type)
+            && rule_option_enabled(config, TIMESTAMP_COLUMN_RULE, "allow_numeric_epoch");
+        let allowed_encoded = encoded_temporal_type(&data_type)
+            && rule_option_enabled(config, TIMESTAMP_COLUMN_RULE, "allow_encoded_values");
+        return (!data_type.contains(TIMESTAMP_TYPE)
+            && !allowed_date
+            && !allowed_epoch
+            && !allowed_encoded)
+            .then(|| {
+                (
+                    TIMESTAMP_COLUMN_RULE,
+                    format!(
+                        "column {:?} implies a timestamp but is typed {data_type}",
+                        column.name
+                    ),
+                )
+            });
+    }
+    if column.name.ends_with("_date") {
+        let allowed_timestamp = data_type.contains(TIMESTAMP_TYPE)
+            && rule_option_enabled(config, DATE_COLUMN_RULE, "allow_timestamps");
+        let allowed_encoded = encoded_temporal_type(&data_type)
+            && rule_option_enabled(config, DATE_COLUMN_RULE, "allow_encoded_values");
+        return (data_type != DATE_TYPE && !allowed_timestamp && !allowed_encoded).then(|| {
+            (
+                DATE_COLUMN_RULE,
+                format!(
+                    "column {:?} implies DATE but is typed {data_type}",
+                    column.name
+                ),
+            )
+        });
+    }
+    None
+}
+
+fn rule_option_enabled(config: &RulesConfig, code: &str, option: &str) -> bool {
+    config
+        .rule_options
+        .get(code)
+        .and_then(|options| options.get(option))
+        .and_then(serde_json::Value::as_bool)
+        .unwrap_or(false)
+}
+
+fn numeric_type(data_type: &str) -> bool {
+    [
+        "BIGINT", "DECIMAL", "DOUBLE", "FLOAT", "INT", "NUMBER", "NUMERIC", "REAL", "SMALLINT",
+    ]
+    .iter()
+    .any(|prefix| data_type.starts_with(prefix))
+}
+
+fn encoded_temporal_type(data_type: &str) -> bool {
+    ["CHAR", "STRING", "TEXT", "VARCHAR", "VARIANT"]
+        .iter()
+        .any(|prefix| data_type.starts_with(prefix))
+}

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/crates/sqlbuild-rules-native/src/rules/_helpers/evaluation.rs

@@ -1,11 +1,12 @@
 use crate::constants::{
-    BOOLEAN_TYPE, DATE_TYPE, DECLARATION_DOMAIN_COMPONENTS, ENFORCED_CONTRACT, NEGATION_OPERATOR,
-    REFERENCE_KIND, SOURCE_REFERENCE_KIND, TIMESTAMP_TYPE, VIEW_MATERIALIZATION,
+    DECLARATION_DOMAIN_COMPONENTS, ENFORCED_CONTRACT, NEGATION_OPERATOR, REFERENCE_KIND,
+    SOURCE_REFERENCE_KIND, VIEW_MATERIALIZATION,
 };
 use crate::models::{Declaration, EvaluateRequest, Fault, Model, RuleMetadata, RulesConfig};
-use crate::rules::_helpers::authored_literals::numeric_literal_tokens;
 use crate::rules::_helpers::domain_layout::folder_layer_details;
-use crate::rules::_helpers::{explicit_output_types, typed_contract_columns};
+use crate::rules::_helpers::{
+    contract_name_types, explicit_output_types, numeric_decisions, typed_contract_columns,
+};
 use crate::rules::models::{
     FaultCollector, ModelEvaluationRequest, ProjectEvaluationRequest, ResolvedThresholdOverride,
 };
@@ -35,6 +36,9 @@ struct Position {
 #[derive(Default)]
 struct ComparisonFact {
     position: Option<Position>,
+    sql: String,
+    equality: bool,
+    output_name: Option<String>,
     columns: BTreeSet<String>,
     string_literals: Vec<String>,
     numeric_literals: Vec<String>,
@@ -64,7 +68,7 @@ struct ParsedModel<'a> {
     query: Query,
     model: &'a Model,
     classification: ModelClassification,
-    authored_numeric_literals: BTreeSet<String>,
+    authored_compact_sql: String,
 }
 
 struct ModelClassification {
@@ -137,14 +141,11 @@ fn evaluate_model_inner(request: ModelEvaluationRequest<'_>) -> Result<Vec<Fault
     };
     let query = *query;
     let classification = classify_model(&query, model, &request.dialect)?;
-    let authored_dialect = rules_dialect(&request.dialect);
-    let authored_numeric_literals =
-        numeric_literal_tokens(&model.authored_sql, authored_dialect.as_ref())?;
     let parsed = ParsedModel {
         query,
         model,
         classification,
-        authored_numeric_literals,
+        authored_compact_sql: numeric_decisions::compact_sql(&model.authored_sql),
     };
     if let Some(rule) = metadata("SQBRMODEL101") {
         import_ctes(&parsed, rule, &faults);
@@ -182,7 +183,7 @@ fn evaluate_model_inner(request: ModelEvaluationRequest<'_>) -> Result<Vec<Fault
     if let Some(rule) = metadata("SQBRCONTRACT105") {
         explicit_output_types::evaluate(&parsed.query, parsed.model, rule, &faults);
     }
-    evaluate_naming_rules(&parsed, selected, &faults);
+    evaluate_naming_rules(&parsed, config, selected, &faults);
     evaluate_literal_rules(&parsed, selected, &faults);
     evaluate_test_rules(TestRuleEvaluation {
         parsed: &parsed,
@@ -1317,51 +1318,12 @@ fn contract_required(parsed: &ParsedModel<'_>, rule: &RuleMetadata, faults: &Fau
 
 fn evaluate_naming_rules(
     parsed: &ParsedModel<'_>,
+    config: &RulesConfig,
     selected: &BTreeMap<String, &RuleMetadata>,
     faults: &FaultCollector,
 ) {
     for column in &parsed.model.columns {
-        let data_type = column.data_type.to_ascii_uppercase();
-        let rule_and_message = if column.name.starts_with("is_")
-            || column.name.starts_with("has_")
-            || column.name.starts_with("can_")
-        {
-            (data_type != BOOLEAN_TYPE).then(|| {
-                (
-                    "SQBRCONTRACT102",
-                    format!(
-                        "column {:?} implies BOOLEAN but is typed {data_type}",
-                        column.name
-                    ),
-                )
-            })
-        } else if column.name.ends_with("_at")
-            || column.name.ends_with("_ts")
-            || column.name.ends_with("_timestamp")
-        {
-            (!data_type.contains(TIMESTAMP_TYPE)).then(|| {
-                (
-                    "SQBRCONTRACT103",
-                    format!(
-                        "column {:?} implies a timestamp but is typed {data_type}",
-                        column.name
-                    ),
-                )
-            })
-        } else if column.name.ends_with("_date") {
-            (data_type != DATE_TYPE).then(|| {
-                (
-                    "SQBRCONTRACT104",
-                    format!(
-                        "column {:?} implies DATE but is typed {data_type}",
-                        column.name
-                    ),
-                )
-            })
-        } else {
-            None
-        };
-        if let Some((code, message)) = rule_and_message
+        if let Some((code, message)) = contract_name_types::finding(column, config)
             && let Some(rule) = selected.get(code)
         {
             faults.push(custom_fault!(parsed.model, rule, None, message, None));
@@ -1400,11 +1362,22 @@ fn evaluate_literal_rules(
         }
         if let Some(rule) = selected.get("SQBRDECLARATION102") {
             let magic = comparison.numeric_literals.iter().any(|literal| {
-                !matches!(literal.as_str(), "-1" | "0" | "1")
-                    && parsed.authored_numeric_literals.contains(literal)
+                numeric_decisions::is_authored_decision(numeric_decisions::AuthoredDecision {
+                    authored_compact_sql: &parsed.authored_compact_sql,
+                    comparison_sql: &comparison.sql,
+                    equality: comparison.equality,
+                    output_name: comparison.output_name.as_deref(),
+                    literal,
+                })
             });
             if magic {
-                faults.push(fault(parsed.model, rule, comparison.position.as_ref()));
+                faults.push(custom_fault!(
+                    parsed.model,
+                    rule,
+                    comparison.position.as_ref(),
+                    format!("non-canonical numeric comparison: {}", comparison.sql),
+                    None,
+                ));
             }
         }
     }
@@ -1672,11 +1645,24 @@ fn select_facts(query: &Query) -> Vec<SelectFacts> {
             }
             for item in &select.projection {
                 match item {
-                    SelectItem::UnnamedExpr(expression)
-                    | SelectItem::ExprWithAlias {
-                        expr: expression, ..
+                    SelectItem::UnnamedExpr(expression) => {
+                        case_comparison_facts(
+                            expression,
+                            None,
+                            &source_context,
+                            &mut result.comparisons,
+                        );
+                    }
+                    SelectItem::ExprWithAlias {
+                        expr: expression,
+                        alias,
                     } => {
-                        case_comparison_facts(expression, &source_context, &mut result.comparisons);
+                        case_comparison_facts(
+                            expression,
+                            Some(&alias.value),
+                            &source_context,
+                            &mut result.comparisons,
+                        );
                     }
                     SelectItem::QualifiedWildcard(_, _) | SelectItem::Wildcard(_) => {}
                 }
@@ -1777,7 +1763,7 @@ fn join_constraint(operator: &JoinOperator) -> Option<&JoinConstraint> {
 }
 
 fn numeric_value(expression: &Expr) -> Option<String> {
-    match expression {
+    match unwrap_nested(expression) {
         Expr::Value(value) => match &value.value {
             Value::Number(value, _) => Some(value.to_string()),
             _ => None,
@@ -1823,6 +1809,7 @@ fn comparison_facts(root: &Expr, source_context: &SourceContext, output: &mut Ve
 
 fn case_comparison_facts(
     root: &Expr,
+    output_name: Option<&str>,
     source_context: &SourceContext,
     output: &mut Vec<ComparisonFact>,
 ) {
@@ -1854,7 +1841,11 @@ fn case_comparison_facts(
         source_context,
         output,
     };
+    let start = visitor.output.len();
     let _ = root.visit(&mut visitor);
+    for fact in &mut visitor.output[start..] {
+        fact.output_name = output_name.map(str::to_owned);
+    }
 }
 
 fn comparison_fact(root: &Expr, source_context: &SourceContext) -> ComparisonFact {
@@ -1874,9 +1865,6 @@ fn comparison_fact(root: &Expr, source_context: &SourceContext) -> ComparisonFac
                     }
                 }
                 Expr::Value(value) => match &value.value {
-                    Value::Number(number, _) => {
-                        self.fact.numeric_literals.push(number.to_string());
-                    }
                     Value::SingleQuotedString(_)
                     | Value::DoubleQuotedString(_)
                     | Value::TripleSingleQuotedString(_)
@@ -1888,11 +1876,6 @@ fn comparison_fact(root: &Expr, source_context: &SourceContext) -> ComparisonFac
                     }
                     _ => {}
                 },
-                Expr::UnaryOp { op, expr } if op.to_string() == NEGATION_OPERATOR => {
-                    if let Some(number) = numeric_value(expr) {
-                        self.fact.numeric_literals.push(format!("-{number}"));
-                    }
-                }
                 _ => {}
             }
             ControlFlow::Continue(())
@@ -1901,6 +1884,14 @@ fn comparison_fact(root: &Expr, source_context: &SourceContext) -> ComparisonFac
     let mut visitor = Values {
         fact: ComparisonFact {
             position: Some(position(root)),
+            sql: root.to_string(),
+            equality: matches!(
+                root,
+                Expr::BinaryOp {
+                    op: BinaryOperator::Eq,
+                    ..
+                }
+            ),
             source_context: source_context.clone(),
             ..ComparisonFact::default()
         },
@@ -1908,6 +1899,9 @@ fn comparison_fact(root: &Expr, source_context: &SourceContext) -> ComparisonFac
     let _ = root.visit(&mut visitor);
     if let Expr::BinaryOp { left, right, .. } = root {
         for operand in [left.as_ref(), right.as_ref()] {
+            if let Some(number) = numeric_value(operand) {
+                visitor.fact.numeric_literals.push(number);
+            }
             if direct_column(operand).is_none() {
                 visitor.fact.modified_columns.extend(column_facts(operand));
             }

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/crates/sqlbuild-rules-native/src/rules/_helpers/mod.rs

@@ -1,7 +1,8 @@
-pub(crate) mod authored_literals;
 pub(crate) mod catalogue;
+pub(crate) mod contract_name_types;
 pub(crate) mod domain_layout;
 pub(crate) mod evaluation;
 pub(crate) mod explicit_output_types;
+pub(crate) mod numeric_decisions;
 pub(crate) mod sql_test_rules;
 pub(crate) mod typed_contract_columns;

sqlbuild-0.106.1/crates/sqlbuild-rules-native/src/rules/_helpers/numeric_decisions.rs

@@ -0,0 +1,77 @@
+const CANONICAL_NUMERIC_DECISIONS: [&str; 3] = ["-1", "0", "1"];
+
+pub(crate) struct AuthoredDecision<'a> {
+    pub(crate) authored_compact_sql: &'a str,
+    pub(crate) comparison_sql: &'a str,
+    pub(crate) equality: bool,
+    pub(crate) output_name: Option<&'a str>,
+    pub(crate) literal: &'a str,
+}
+
+pub(crate) fn compact_sql(sql: &str) -> String {
+    let bytes = sql.as_bytes();
+    let mut compact = Vec::with_capacity(bytes.len());
+    let mut index = 0;
+    let mut quote: Option<u8> = None;
+    let mut line_comment = false;
+    let mut block_comment = false;
+    while index < bytes.len() {
+        let byte = bytes[index];
+        let next = bytes.get(index + 1).copied();
+        if line_comment {
+            line_comment = byte != b'\n';
+            index += 1;
+            continue;
+        }
+        if block_comment {
+            if byte == b'*' && next == Some(b'/') {
+                block_comment = false;
+                index += 2;
+            } else {
+                index += 1;
+            }
+            continue;
+        }
+        if let Some(active_quote) = quote {
+            compact.push(byte.to_ascii_lowercase());
+            if byte == active_quote {
+                if next == Some(active_quote) {
+                    compact.push(active_quote);
+                    index += 2;
+                    continue;
+                }
+                quote = None;
+            }
+            index += 1;
+            continue;
+        }
+        if byte == b'-' && next == Some(b'-') {
+            line_comment = true;
+            index += 2;
+            continue;
+        }
+        if byte == b'/' && next == Some(b'*') {
+            block_comment = true;
+            index += 2;
+            continue;
+        }
+        if matches!(byte, b'\'' | b'"') {
+            quote = Some(byte);
+        }
+        if !byte.is_ascii_whitespace() {
+            compact.push(byte.to_ascii_lowercase());
+        }
+        index += 1;
+    }
+    String::from_utf8(compact).unwrap_or_default()
+}
+
+pub(crate) fn is_authored_decision(decision: AuthoredDecision<'_>) -> bool {
+    !CANONICAL_NUMERIC_DECISIONS.contains(&decision.literal)
+        && decision
+            .authored_compact_sql
+            .contains(&compact_sql(decision.comparison_sql))
+        && !decision.output_name.is_some_and(|name| {
+            decision.equality && name.ends_with(&format!("_{}", decision.literal))
+        })
+}

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/pyproject.toml

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

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/src/sqlbuild/compiler/compile/_helpers/analysis/cte_facts.py

@@ -624,14 +624,10 @@ def _polyglot_top_level_ctes(root: Any) -> tuple[tuple[str, Any, bool], ...]:
     )
     if not isinstance(raw_ctes, list):
         return ()
-    cte_bodies: tuple[Any, ...] = tuple(
-        child
-        for child in root.children()
-        if str(getattr(child, "kind", ""))
-        in {_POLYGLOT_KIND_SELECT, *_POLYGLOT_SET_OPERATION_KINDS}
-    )
-    if len(cte_bodies) != len(raw_ctes):
+    children: tuple[Any, ...] = tuple(root.children())
+    if len(children) < len(raw_ctes):
         return ()
+    cte_bodies: tuple[Any, ...] = children[-len(raw_ctes) :]
     ctes: list[tuple[str, Any, bool]] = []
     for raw_cte, body in zip(raw_ctes, cte_bodies, strict=True):
         if not isinstance(raw_cte, dict):

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/src/sqlbuild/compiler/compile/_helpers/assembly/project.py

@@ -416,6 +416,7 @@ def _assemble_compiled_model(
         fast_lineage_columns=fast_lineage_columns,
         fast_lineage_has_star=fast_lineage_has_star,
         authored_sql=model_input.model_file.contents,
+        authored_query_sql=model_input.model_file.query_sql,
         output_column_locations=model_input.model_file.output_column_locations,
         extract_implicit_alias_columns=model_input.model_file.extract_implicit_alias_columns,
         macro_deps=model_input.macro_deps or find_macro_call_names(model_input.macro_source_sql),

{sqlbuild-0.105.0 → sqlbuild-0.106.1}/src/sqlbuild/compiler/compile/models.py

@@ -731,6 +731,7 @@ class CompiledModel:
     fast_lineage_columns: tuple[CompiledLineageColumnFact, ...] | None = None
     fast_lineage_has_star: bool = False
     authored_sql: str = ""
+    authored_query_sql: str = ""
     output_column_locations: dict[str, SourceLocation] = field(default_factory=dict)
     extract_implicit_alias_columns: bool = True
     macro_deps: tuple[str, ...] = field(default_factory=tuple)