feat: answer simple commands in sqb, upgrade fensu and accept SharedMergeTree

.github/workflows/build-distributions.yml

@@ -88,7 +88,7 @@ jobs:
     name: Build wheel (${{ matrix.platform.name }})
     needs: source
     runs-on: ${{ matrix.platform.runner }}
-    timeout-minutes: 45
+    timeout-minutes: 75
     strategy:
       fail-fast: false
       matrix:

.github/workflows/verify.yml

@@ -255,7 +255,7 @@ jobs:
     needs: [changes, lockfile]
     if: needs.changes.outputs.checks == 'true'
     runs-on: ubuntu-24.04
-    timeout-minutes: 30
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/setup-uv@v5
@@ -342,7 +342,7 @@ jobs:
     needs: [changes, lockfile]
     if: needs.changes.outputs.compiler_differential == 'true'
     runs-on: ubuntu-24.04
-    timeout-minutes: 30
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/setup-uv@v5
@@ -379,7 +379,7 @@ jobs:
     needs: [changes, lockfile]
     if: needs.changes.outputs.compiler_differential == 'true'
     runs-on: ubuntu-24.04
-    timeout-minutes: 20
+    timeout-minutes: 45
     strategy:
       fail-fast: false
       matrix:
@@ -415,7 +415,7 @@ jobs:
     needs: [changes, lockfile]
     if: needs.changes.outputs.compiler_differential == 'true'
     runs-on: windows-2025
-    timeout-minutes: 40
+    timeout-minutes: 45
     defaults:
       run:
         shell: bash
@@ -468,7 +468,7 @@ jobs:
     needs: [changes, lockfile]
     if: needs.changes.outputs.format_performance == 'true'
     runs-on: ubuntu-24.04
-    timeout-minutes: 30
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/setup-uv@v5
@@ -499,7 +499,7 @@ jobs:
     # These budgets are calibrated for the 8-vCPU Blacksmith runner.
     if: false
     runs-on: ubuntu-24.04
-    timeout-minutes: 15
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/setup-uv@v5
@@ -524,7 +524,7 @@ jobs:
     needs: [changes, lockfile]
     if: needs.changes.outputs.performance == 'true'
     runs-on: ubuntu-24.04
-    timeout-minutes: 15
+    timeout-minutes: 45
     strategy:
       fail-fast: false
       matrix:
@@ -572,7 +572,7 @@ jobs:
     if: needs.changes.outputs.performance == 'true'
     runs-on: ubuntu-24.04
     # The 3k and 10k cells also run the delta edit-loop guard, about five minutes at 10k.
-    timeout-minutes: 30
+    timeout-minutes: 45
     strategy:
       fail-fast: false
       matrix:
@@ -717,7 +717,7 @@ jobs:
     needs: [changes, lockfile]
     if: needs.changes.outputs.performance == 'true'
     runs-on: ubuntu-24.04
-    timeout-minutes: 30
+    timeout-minutes: 45
     strategy:
       fail-fast: false
       matrix:
@@ -788,7 +788,7 @@ jobs:
     # These budgets are calibrated for the 8-vCPU Blacksmith runner.
     if: false
     runs-on: ubuntu-24.04
-    timeout-minutes: 15
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/setup-uv@v5

Cargo.toml

@@ -90,7 +90,7 @@ ruff_text_size = "=0.0.4"
 rustc-hash = "2"
 # Recall's local store: SQLite compiled in, so every build has the same engine version.
 rusqlite = { version = "0.37", features = ["bundled"] }
-rustix = { version = "1.1.4", default-features = false, features = ["fs", "std"] }
+rustix = { version = "1.1.4", default-features = false, features = ["fs", "std", "termios"] }
 saphyr-parser = "0.1"
 regex = "1"
 serde = { version = "1", features = ["derive"] }

crates/sqlbuild-analysis/src/assembly/analysis_session/_helpers/analysis_cache.rs

@@ -16,7 +16,7 @@ use crate::assembly::analysis_session::models::{
     LineageRow, ModelAnalysis, ModelOutcome, ModelRequest, SessionRequest,
 };
 use crate::assembly::analysis_session::types::{Pairs, Shapes};
-use crate::semantic_validation::types::DiagnosticRow;
+use crate::semantic_validation::models::DiagnosticRow;
 
 const LINEAGE_NATIVE: u64 = 0;
 const LINEAGE_FACTS: u64 = 1;
@@ -454,7 +454,16 @@ pub(crate) fn encode_outcome(
     encoder.flag(analysis.has_star);
     encoder.flag(analysis.star_resolved);
     encoder.uint(analysis.binding_diagnostics.len() as u64);
-    for (code, message, line, column, start, end, severity) in &analysis.binding_diagnostics {
+    for DiagnosticRow {
+        code,
+        message,
+        line,
+        column,
+        start,
+        end,
+        severity,
+    } in &analysis.binding_diagnostics
+    {
         encoder.text(code);
         encoder.text(message);
         for position in [line, column, start, end] {
@@ -529,15 +538,15 @@ pub(crate) fn decode_outcome(
     let diagnostic_count: usize = decoder.index()?;
     let mut binding_diagnostics: Vec<DiagnosticRow> = Vec::new();
     for _ in 0..diagnostic_count {
-        binding_diagnostics.push((
-            decoder.text()?,
-            decoder.text()?,
-            decoder.optional_index()?,
-            decoder.optional_index()?,
-            decoder.optional_index()?,
-            decoder.optional_index()?,
-            decoder.text()?,
-        ));
+        binding_diagnostics.push(DiagnosticRow {
+            code: decoder.text()?,
+            message: decoder.text()?,
+            line: decoder.optional_index()?,
+            column: decoder.optional_index()?,
+            start: decoder.optional_index()?,
+            end: decoder.optional_index()?,
+            severity: decoder.text()?,
+        });
     }
     let binding_validated: bool = decoder.flag()?;
     decoder.finish()?;

crates/sqlbuild-analysis/src/assembly/analysis_session/_helpers/compact_batch.rs

@@ -23,7 +23,8 @@ use crate::assembly::analysis_session::constants::{
 use crate::assembly::analysis_session::models::{ColumnFact, LineageRow};
 use crate::assembly::analysis_session::types::{Pairs, Shapes};
 use crate::semantic_validation::main::diagnostics::binding_diagnostics;
-use crate::semantic_validation::types::{DiagnosticRow, NormalizationRequest, Relations};
+use crate::semantic_validation::models::DiagnosticRow;
+use crate::semantic_validation::types::{NormalizationRequest, Relations};
 
 const INVALID_BATCH: &str = "native compact query analysis returned an invalid batch response";
 const INVALID_TEMPLATE: &str = "native compact query analysis returned an invalid template";
@@ -1424,15 +1425,15 @@ fn diagnostic_row(error: &Value) -> Result<Option<DiagnosticRow>, String> {
         Some(Value::String(message)) if !message.is_empty() => message.clone(),
         _ => DEFAULT_BINDING_MESSAGE.to_owned(),
     };
-    Ok(Some((
-        code.to_owned(),
+    Ok(Some(DiagnosticRow {
+        code: code.to_owned(),
         message,
-        position(error, "line")?,
-        position(error, "column")?,
-        position(error, "start")?,
-        position(error, "end")?,
-        severity.to_owned(),
-    )))
+        line: position(error, "line")?,
+        column: position(error, "column")?,
+        start: position(error, "start")?,
+        end: position(error, "end")?,
+        severity: severity.to_owned(),
+    }))
 }
 
 fn position(error: &Value, key: &str) -> Result<Option<usize>, String> {

crates/sqlbuild-analysis/src/assembly/analysis_session/_helpers/dynamic_pivot.rs

@@ -192,7 +192,12 @@ fn pivot_proof(
     if truthy(pivot.get("unpivot")) {
         return failure("UNPIVOT does not produce a dynamic column family".to_owned());
     }
-    let (pivot_columns, aggregates, dynamic, columns_valid) = components(pivot, context.dialect);
+    let PivotComponents {
+        pivot_columns,
+        aggregates,
+        dynamic,
+        columns_valid,
+    } = components(pivot, context.dialect);
     if !dynamic {
         return failure(
             "static pivot values must use ordinary exact column declarations".to_owned(),
@@ -309,24 +314,31 @@ fn fixed_names(
         .collect()
 }
 
+/// Python's `_pivot_components` for one pivot clause.
+struct PivotComponents<'a> {
+    pivot_columns: Vec<&'a str>,
+    aggregates: Vec<&'a Value>,
+    /// Whether the pivot values come from a dynamic source.
+    dynamic: bool,
+    /// Whether every pivot column resolved to a name.
+    columns_valid: bool,
+}
+
 /// Python's `_pivot_components`: pivot columns, aggregates, dynamic values, columns valid.
-fn components<'a>(
-    pivot: &'a Map<String, Value>,
-    dialect: &str,
-) -> (Vec<&'a str>, Vec<&'a Value>, bool, bool) {
+fn components<'a>(pivot: &'a Map<String, Value>, dialect: &str) -> PivotComponents<'a> {
     if SIMPLIFIED_PIVOT_DIALECTS.contains(&dialect) && truthy(pivot.get("using")) {
         let expressions: Vec<&Value> = dict_list(pivot.get("expressions"));
         let columns: Vec<&str> = expressions
             .iter()
             .filter_map(|expression| column_name(Some(expression)))
             .collect();
         let valid: bool = columns.len() == expressions.len();
-        return (
-            columns,
-            dict_list(pivot.get("using")),
-            !truthy(pivot.get("fields")),
-            valid,
-        );
+        return PivotComponents {
+            pivot_columns: columns,
+            aggregates: dict_list(pivot.get("using")),
+            dynamic: !truthy(pivot.get("fields")),
+            columns_valid: valid,
+        };
     }
     let fields: Vec<&Value> = dict_list(pivot.get("fields"));
     let columns: Vec<&str> = fields
@@ -335,7 +347,12 @@ fn components<'a>(
         .collect();
     let dynamic: bool = fields.iter().any(|field| has_dynamic_values(field));
     let valid: bool = columns.len() == fields.len();
-    (columns, dict_list(pivot.get("expressions")), dynamic, valid)
+    PivotComponents {
+        pivot_columns: columns,
+        aggregates: dict_list(pivot.get("expressions")),
+        dynamic,
+        columns_valid: valid,
+    }
 }
 
 /// Python's `_has_dynamic_value_source` for one pivot field.
@@ -651,13 +668,24 @@ fn failure(reason: String) -> PivotOutcome {
 }
 
 /// Python's `_families_equal` key for one family.
-fn normalized(family: &DynamicFamily) -> (String, String, String, String, String, Option<&str>) {
-    (
-        casefold(&family.name),
-        casefold(&family.pivot_column),
-        casefold(&family.value_column),
-        casefold(&family.aggregate),
-        casefold(&family.data_type),
-        family.name_pattern.as_deref(),
-    )
+#[derive(PartialEq, Eq)]
+struct FamilyKey<'a> {
+    name: String,
+    pivot_column: String,
+    value_column: String,
+    aggregate: String,
+    data_type: String,
+    name_pattern: Option<&'a str>,
+}
+
+/// Python's `_families_equal` key for one family.
+fn normalized(family: &DynamicFamily) -> FamilyKey<'_> {
+    FamilyKey {
+        name: casefold(&family.name),
+        pivot_column: casefold(&family.pivot_column),
+        value_column: casefold(&family.value_column),
+        aggregate: casefold(&family.aggregate),
+        data_type: casefold(&family.data_type),
+        name_pattern: family.name_pattern.as_deref(),
+    }
 }

crates/sqlbuild-analysis/src/assembly/analysis_session/_helpers/session.rs

@@ -36,8 +36,8 @@ use crate::assembly::analysis_session::models::{
     RelationTables, SessionModelFacts, SessionOutcome, SessionRequest, SessionStep,
 };
 use crate::assembly::analysis_session::types::{Pairs, Shapes};
+use crate::semantic_validation::models::DiagnosticRow;
 use crate::semantic_validation::models::ProjectCatalog;
-use crate::semantic_validation::types::DiagnosticRow;
 
 /// What an internal native failure of the session names.
 const SESSION_CONTEXT: &str = "native model analysis";

crates/sqlbuild-analysis/src/assembly/analysis_session/models.rs

@@ -11,7 +11,7 @@ use sqlbuild_cache::store::models::NativeStore;
 use crate::assembly::analysis_session::_helpers::catalog_state::SessionCatalog;
 use crate::assembly::analysis_session::_helpers::mappings::ShapeTable;
 use crate::assembly::analysis_session::types::{NullabilityRuleFn, OutputSources, Pairs, Shapes};
-use crate::semantic_validation::types::DiagnosticRow;
+use crate::semantic_validation::models::DiagnosticRow;
 
 /// One `ref`, `source`, `seed`, `table_fn` or `udf` call a model's SQL makes.
 #[derive(Debug, Clone, PartialEq, Eq)]

crates/sqlbuild-analysis/src/assembly/analysis_session/tests/helpers.rs

@@ -230,7 +230,7 @@ pub(crate) fn described(outcome: &ModelOutcome) -> Vec<String> {
         analysis
             .binding_diagnostics
             .iter()
-            .map(|row| row.0.as_str())
+            .map(|row| row.code.as_str())
             .collect::<Vec<_>>()
     ));
     lines

crates/sqlbuild-analysis/src/binding_locations/main/locate_binding_diagnostics.rs

@@ -3,9 +3,11 @@
 use std::collections::HashSet;
 
 use crate::binding_locations::constants::{ERROR_SEVERITY, UNKNOWN_TABLE_INTERNAL_CODE};
-use crate::binding_locations::models::{AuthoredSpan, BindingSource, LocatedDiagnostic};
+use crate::binding_locations::models::{
+    AuthoredSpan, BindingSource, LocatedDiagnostic, SeenDiagnostic,
+};
+use crate::semantic_validation::models::DiagnosticRow;
 use crate::semantic_validation::models::{BindingPositions, PositionInput};
-use crate::semantic_validation::types::DiagnosticRow;
 
 /// Each reported diagnostic in order; an error mapping a position is the mapper's message.
 pub fn locate_binding_diagnostics(
@@ -17,9 +19,18 @@ pub fn locate_binding_diagnostics(
         .find(source.query)
         .map(|start| source.authored[..start].matches('\n').count());
     let mut positions: Option<BindingPositions> = None;
-    let mut seen: HashSet<(String, String, Option<usize>, Option<usize>)> = HashSet::new();
+    let mut seen: HashSet<SeenDiagnostic> = HashSet::new();
     let mut located: Vec<LocatedDiagnostic> = Vec::new();
-    for (code, message, line, column, start, end, severity) in rows {
+    for DiagnosticRow {
+        code,
+        message,
+        line,
+        column,
+        start,
+        end,
+        severity,
+    } in rows
+    {
         if code == UNKNOWN_TABLE_INTERNAL_CODE {
             continue;
         }
@@ -39,7 +50,12 @@ pub fn locate_binding_diagnostics(
                 *column,
             ),
         };
-        let key = (code.clone(), message.clone(), line, column);
+        let key = SeenDiagnostic {
+            code: code.clone(),
+            message: message.clone(),
+            line,
+            column,
+        };
         if seen.contains(&key) && start.is_some() && severity == ERROR_SEVERITY {
             continue;
         }