sqlbuild-cli 0.186.1__tar.gz → 0.186.2__tar.gz

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/Cargo.lock

@@ -1209,7 +1209,7 @@ checksum = "5b3dc8af474f516a851ff4bd12db780f948b9250ad37211e4eec0bccea54e01b"
 
 [[package]]
 name = "sqlbuild-analysis"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "memchr",
  "polyglot-sql",
@@ -1232,7 +1232,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-attachments"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "sqlbuild-core",
  "sqlbuild-sqltext",
@@ -1240,7 +1240,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-build-features"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "arrayvec",
  "bstr",
@@ -1257,7 +1257,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-cache"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "blake3",
  "rayon",
@@ -1270,7 +1270,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-cli"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "blake3",
  "ctrlc",
@@ -1290,7 +1290,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-config"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "saphyr-parser",
  "sqlbuild-core",
@@ -1301,7 +1301,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-core"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "regex",
  "sha2",
@@ -1309,14 +1309,14 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-cursor"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "sqlbuild-core",
 ]
 
 [[package]]
 name = "sqlbuild-discovery"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "junction",
  "rayon",
@@ -1330,14 +1330,14 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-host"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "sqlbuild-core",
 ]
 
 [[package]]
 name = "sqlbuild-model-config"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "regex",
  "sqlbuild-core",
@@ -1345,7 +1345,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-project"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "sqlbuild-analysis",
  "sqlbuild-core",
@@ -1354,7 +1354,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-pysource"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "ruff_python_ast",
  "ruff_python_parser",
@@ -1365,12 +1365,13 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-python"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "fensu-policy",
  "mimalloc",
  "pyo3",
  "rayon",
+ "rusqlite",
  "rustc-hash",
  "serde",
  "serde_json",
@@ -1399,7 +1400,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-recall"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "blake3",
  "rusqlite",
@@ -1413,7 +1414,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-refactor"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "serde",
  "serde_json",
@@ -1428,7 +1429,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-render"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "serde_json",
  "sqlbuild-cache",
@@ -1439,7 +1440,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-rules"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "blake3",
  "fensu-policy",
@@ -1464,7 +1465,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-scopes"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "serde_json",
  "sha2",
@@ -1477,7 +1478,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-sqltext"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "rayon",
  "serde",
@@ -1486,7 +1487,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-state"
-version = "0.186.1"
+version = "0.186.2"
 dependencies = [
  "serde_json",
  "sha2",

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/Cargo.toml

@@ -33,7 +33,7 @@ python-boundary = "sqlbuild-python"
 polyglot-floor = "sqlbuild-analysis"
 
 [workspace.package]
-version = "0.186.1"
+version = "0.186.2"
 edition = "2024"
 license = "Apache-2.0"
 publish = false

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild-cli
-Version: 0.186.1
+Version: 0.186.2
 License-File: LICENSE
 Summary: The native sqb and sqlbuild executables of SQLBuild
 License-Expression: Apache-2.0

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/crates/sqlbuild-analysis/src/graph/_helpers/indexes.rs

@@ -4,20 +4,14 @@ use std::collections::{HashMap, HashSet};
 
 use crate::assembly::project::types::ObjectKey;
 use crate::graph::constants::{MODEL_ROOT, MODEL_ROOT_PREFIX, SQL_TEST_RESOURCE};
-use crate::graph::models::{GraphIndexes, GraphResource, ProjectGraph};
+use crate::graph::main::downstream_edges::downstream_edges;
+use crate::graph::models::{GraphIndexes, GraphResource, OrderedEdges, ProjectGraph};
 
 type Edges = Vec<(ObjectKey, Vec<ObjectKey>)>;
 
-/// Insertion-ordered key lists, as Python's `dict.setdefault(key, []).append(...)` builds them.
-#[derive(Default)]
-struct OrderedEdges {
-    entries: Edges,
-    index: HashMap<ObjectKey, usize>,
-}
-
 impl OrderedEdges {
     /// The list stored for `key`, appended empty in insertion order when the key is new.
-    fn list(&mut self, key: &ObjectKey) -> &mut Vec<ObjectKey> {
+    pub(crate) fn list(&mut self, key: &ObjectKey) -> &mut Vec<ObjectKey> {
         let position: usize = match self.index.get(key) {
             Some(&position) => position,
             None => {
@@ -28,6 +22,13 @@ impl OrderedEdges {
         };
         &mut self.entries[position].1
     }
+
+    /// The dependencies already stored for `key`, without inserting a missing target.
+    pub(crate) fn get(&self, key: &ObjectKey) -> Option<&Vec<ObjectKey>> {
+        self.index
+            .get(key)
+            .map(|&position| &self.entries[position].1)
+    }
 }
 
 /// Tag to keys in first-tagged order, each key once, as Python's tag sets hold them.
@@ -70,7 +71,7 @@ pub(crate) fn build(resources: &[GraphResource]) -> ProjectGraph {
     {
         *upstream.list(&resource.key) = lineage_deps(&resource.deps);
     }
-    let downstream: Edges = downstream(&upstream.entries);
+    let downstream: Edges = downstream_edges(&upstream.entries);
     let mut tags: OrderedTags = OrderedTags::default();
     let mut graph = ProjectGraph {
         downstream_index: positions(&downstream),
@@ -125,24 +126,6 @@ fn lineage_deps(deps: &[ObjectKey]) -> Vec<ObjectKey> {
         .collect()
 }
 
-/// Inverted edges keyed in upstream order, each list sorted by `(resource type, name)`.
-fn downstream(upstream: &[(ObjectKey, Vec<ObjectKey>)]) -> Edges {
-    let mut inverted: OrderedEdges = OrderedEdges::default();
-    for (key, _) in upstream {
-        let _ = inverted.list(key);
-    }
-    for (key, deps) in upstream {
-        for dep in deps {
-            inverted.list(dep).push(key.clone());
-        }
-    }
-    let mut entries: Edges = inverted.entries;
-    for (_, keys) in &mut entries {
-        keys.sort();
-    }
-    entries
-}
-
 fn positions(entries: &[(ObjectKey, Vec<ObjectKey>)]) -> HashMap<ObjectKey, usize> {
     entries
         .iter()

sqlbuild_cli-0.186.2/crates/sqlbuild-analysis/src/graph/main/downstream_edges.rs

@@ -0,0 +1,24 @@
+//! Reverse ordered execution or lineage edges without projecting Python graph maps.
+
+use crate::assembly::project::types::ObjectKey;
+use crate::graph::models::OrderedEdges;
+
+/// Inverted edges keyed in upstream order, each list sorted by `(resource type, name)`.
+pub fn downstream_edges(
+    upstream: &[(ObjectKey, Vec<ObjectKey>)],
+) -> Vec<(ObjectKey, Vec<ObjectKey>)> {
+    let mut inverted = OrderedEdges::default();
+    for (key, _) in upstream {
+        let _ = inverted.list(key);
+    }
+    for (key, deps) in upstream {
+        for dep in deps {
+            inverted.list(dep).push(key.clone());
+        }
+    }
+    let mut entries = inverted.entries;
+    for (_, keys) in &mut entries {
+        keys.sort();
+    }
+    entries
+}

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/crates/sqlbuild-analysis/src/graph/main/mod.rs

@@ -1,10 +1,13 @@
 pub mod build_project_graph;
 pub mod build_resources;
+pub mod downstream_edges;
 pub mod edge_keys;
 pub mod graph_from_indexes;
 pub mod match_selector;
 pub mod model_layer_count;
 pub mod parse_selector;
+pub mod reachable_graph_keys;
+pub mod reachable_keys;
 pub mod resolve_selector_tokens;
 pub mod resolve_selectors;
 pub mod selector_name_help;

sqlbuild_cli-0.186.2/crates/sqlbuild-analysis/src/graph/main/reachable_graph_keys.rs

@@ -0,0 +1,23 @@
+//! Reachable keys over the project's existing edge indexes.
+
+use std::collections::HashSet;
+use std::convert::Infallible;
+
+use sqlbuild_core::graph_walk::main::breadth_first_reach::breadth_first_reach;
+
+use crate::assembly::project::types::ObjectKey;
+use crate::graph::main::edge_keys::edge_keys;
+use crate::graph::models::{EdgeDirection, ProjectGraph};
+
+/// The starts and every key reachable in the given direction.
+pub fn reachable_graph_keys(
+    starts: &[ObjectKey],
+    graph: &ProjectGraph,
+    direction: EdgeDirection,
+) -> HashSet<ObjectKey> {
+    let mut visited: HashSet<&ObjectKey> = starts.iter().collect();
+    let Ok(()) = breadth_first_reach(starts, None, &mut visited, |current| {
+        Ok::<_, Infallible>(edge_keys(graph, current, direction))
+    });
+    visited.into_iter().cloned().collect()
+}

sqlbuild_cli-0.186.2/crates/sqlbuild-analysis/src/graph/main/reachable_keys.rs

@@ -0,0 +1,21 @@
+//! Reachable compiled resource keys without projecting an intermediate host graph.
+
+use std::collections::{HashMap, HashSet};
+use std::convert::Infallible;
+
+use sqlbuild_core::graph_walk::main::breadth_first_reach::breadth_first_reach;
+
+use crate::assembly::project::types::ObjectKey;
+
+/// The starts and every key reachable through the ordered dependency lists.
+pub fn reachable_keys(
+    starts: &[ObjectKey],
+    edges: &[(ObjectKey, Vec<ObjectKey>)],
+) -> HashSet<ObjectKey> {
+    let index: HashMap<_, _> = edges.iter().map(|(key, deps)| (key, deps)).collect();
+    let mut visited: HashSet<&ObjectKey> = starts.iter().collect();
+    let Ok(()) = breadth_first_reach(starts, None, &mut visited, |current| {
+        Ok::<_, Infallible>(index.get(current).map_or(&[][..], |deps| deps.as_slice()))
+    });
+    visited.into_iter().cloned().collect()
+}

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/crates/sqlbuild-analysis/src/graph/models.rs

@@ -4,6 +4,13 @@ use std::collections::HashMap;
 
 use crate::assembly::project::types::ObjectKey;
 
+/// Dependency lists indexed without losing project insertion order.
+#[derive(Debug, Default)]
+pub(crate) struct OrderedEdges {
+    pub(crate) entries: Vec<(ObjectKey, Vec<ObjectKey>)>,
+    pub(crate) index: HashMap<ObjectKey, usize>,
+}
+
 /// One graph resource in project order: its key, upstream keys, tags and model folder.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct GraphResource {

sqlbuild_cli-0.186.2/crates/sqlbuild-analysis/src/planner_identity/main/execution_upstream.rs

@@ -0,0 +1,58 @@
+//! Execution edges in project order, including SQL tests and injected reads.
+
+use std::collections::{HashMap, HashSet};
+
+use crate::assembly::project::types::ObjectKey;
+use crate::graph::models::OrderedEdges;
+use crate::planner_identity::constants::{TABLE_FN_RESOURCE, UDF_RESOURCE};
+use crate::planner_identity::models::ExecutionTest;
+
+/// Weave tests before their targets and append distinct gate and hook dependencies.
+pub fn execution_upstream(
+    resources: Vec<(ObjectKey, Vec<ObjectKey>)>,
+    tests: &[ExecutionTest],
+    injected: &[(ObjectKey, ObjectKey)],
+) -> Vec<(ObjectKey, Vec<ObjectKey>)> {
+    let mut upstream = OrderedEdges::default();
+    for (key, deps) in resources {
+        *upstream.list(&key) = deps;
+    }
+    for test in tests {
+        let mut seen: HashSet<ObjectKey> = HashSet::new();
+        let deps: Vec<ObjectKey> = if test.table_function {
+            test.scope_deps
+                .iter()
+                .filter(|key| matches!(key.0.as_str(), UDF_RESOURCE | TABLE_FN_RESOURCE))
+                .cloned()
+                .collect()
+        } else {
+            test.scope_deps
+                .iter()
+                .filter_map(|target| upstream.get(target))
+                .flatten()
+                .filter(|key| matches!(key.0.as_str(), UDF_RESOURCE | TABLE_FN_RESOURCE))
+                .filter(|key| seen.insert((*key).clone()))
+                .cloned()
+                .collect()
+        };
+        *upstream.list(&test.key) = deps;
+        if !test.table_function {
+            for target in &test.scope_deps {
+                if upstream.get(target).is_some() {
+                    upstream.list(target).push(test.key.clone());
+                }
+            }
+        }
+    }
+    let mut injected_seen: HashMap<ObjectKey, HashSet<ObjectKey>> = HashMap::new();
+    for (gated, read) in injected {
+        let deps = upstream.list(gated);
+        let seen = injected_seen
+            .entry(gated.clone())
+            .or_insert_with(|| deps.iter().cloned().collect());
+        if seen.insert(read.clone()) {
+            deps.push(read.clone());
+        }
+    }
+    upstream.entries
+}

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/crates/sqlbuild-analysis/src/planner_identity/main/mod.rs

@@ -1,4 +1,5 @@
 pub mod classify_selection_staleness;
+pub mod execution_upstream;
 pub mod expected_graph_identity_hashes;
 pub mod function_fingerprint_sql;
 pub mod graph_write_identity_hashes;

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/crates/sqlbuild-analysis/src/planner_identity/models.rs

@@ -2,6 +2,8 @@
 
 use std::collections::{HashMap, HashSet};
 
+use crate::assembly::project::types::ObjectKey;
+
 /// A graph node identity: resource type (or fingerprint node type) and name, ordered as Python's `(resource_type, name)`.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct GraphKey {
@@ -9,6 +11,23 @@ pub struct GraphKey {
     pub name: String,
 }
 
+impl From<&ObjectKey> for GraphKey {
+    fn from((kind, name): &ObjectKey) -> Self {
+        Self {
+            kind: kind.clone(),
+            name: name.clone(),
+        }
+    }
+}
+
+/// One SQL test woven into its targets' execution dependencies.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ExecutionTest {
+    pub key: ObjectKey,
+    pub scope_deps: Vec<ObjectKey>,
+    pub table_function: bool,
+}
+
 /// One node of an identity graph: its upstream keys in order and its local hash.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct IdentityNode {

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/crates/sqlbuild-cache/src/artifacts/constants.rs

@@ -1,5 +1,10 @@
 /// The mode new artifacts are created with before the process umask, as Python's `os.open`.
 pub const NEW_FILE_MODE: u32 = 0o666;
+/// The existing SQL-test cache snapshot format, shared by native readers and writers.
+pub(crate) const SQL_TEST_CACHE_VERSION: u64 = 5;
+pub(crate) const SQL_TEST_CACHE_FILE: &str = "sql-test-artifacts.json";
+pub(crate) const MAX_SQL_TEST_CACHE_BYTES: u64 = 10_000_000;
+pub(crate) const MAX_SQL_TEST_CACHE_RECORDS: usize = 100_000;
 /// The extension every compiled SQL test artifact carries.
 pub(crate) const SQL_EXTENSION: &str = "sql";
 #[cfg(unix)]

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/crates/sqlbuild-cache/src/artifacts/main/mod.rs

@@ -1,8 +1,9 @@
 pub mod new_sql_test_record;
 pub mod publish_staged;
+pub mod read_sql_test_cache;
 pub mod remove_stale;
 pub mod remove_stale_unless_unchanged;
 pub mod reusable_sql_test_record;
 pub mod staged_files;
-pub mod stored_sql_test_record;
 pub mod write_artifacts;
+pub mod write_sql_test_cache;

sqlbuild_cli-0.186.2/crates/sqlbuild-cache/src/artifacts/main/read_sql_test_cache.rs

@@ -0,0 +1,66 @@
+//! Read the persisted SQL-test artifact records without an interpreter.
+
+use std::collections::HashMap;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::artifacts::_helpers::sql_test_records::{
+    is_safe_relative_sql_path, normalized_relative_path,
+};
+use crate::artifacts::constants::{
+    MAX_SQL_TEST_CACHE_BYTES, MAX_SQL_TEST_CACHE_RECORDS, SQL_TEST_CACHE_FILE,
+    SQL_TEST_CACHE_VERSION,
+};
+use crate::artifacts::models::SqlTestArtifactRecord;
+
+/// Valid records in the existing snapshot; an unreadable or malformed cache is a miss.
+#[must_use]
+pub fn read_sql_test_cache(directory: &Path) -> HashMap<String, SqlTestArtifactRecord> {
+    let path = directory.join(SQL_TEST_CACHE_FILE);
+    let Ok(metadata) = std::fs::metadata(&path) else {
+        return HashMap::new();
+    };
+    if !metadata.is_file() || metadata.len() > MAX_SQL_TEST_CACHE_BYTES {
+        return HashMap::new();
+    }
+    let Ok(bytes) = std::fs::read(&path) else {
+        return HashMap::new();
+    };
+    let Ok(payload) = serde_json::from_slice::<Value>(&bytes) else {
+        return HashMap::new();
+    };
+    if payload.get("version").and_then(Value::as_f64) != Some(SQL_TEST_CACHE_VERSION as f64) {
+        return HashMap::new();
+    }
+    let Some(rows) = payload.get("records").and_then(Value::as_object) else {
+        return HashMap::new();
+    };
+    if rows.len() > MAX_SQL_TEST_CACHE_RECORDS {
+        return HashMap::new();
+    }
+    let mut records: HashMap<String, SqlTestArtifactRecord> = HashMap::new();
+    for (key, value) in rows {
+        if let Some(record) = record(value) {
+            records.insert(key.clone(), record);
+        }
+    }
+    records
+}
+
+fn record(value: &Value) -> Option<SqlTestArtifactRecord> {
+    let relative_path = normalized_relative_path(Path::new(value.get("relative_path")?.as_str()?));
+    if !is_safe_relative_sql_path(&relative_path) {
+        return None;
+    }
+    let Ok(mtime_ns) = i64::try_from(value.get("mtime_ns")?.as_u64()?) else {
+        return None;
+    };
+    Some(SqlTestArtifactRecord {
+        identity: value.get("identity")?.as_str()?.to_owned(),
+        relative_path,
+        size: value.get("size")?.as_u64()?,
+        mtime_ns,
+        content_sha256: value.get("content_sha256")?.as_str()?.to_owned(),
+    })
+}

sqlbuild_cli-0.186.2/crates/sqlbuild-cache/src/artifacts/main/write_sql_test_cache.rs

@@ -0,0 +1,64 @@
+//! Publish the existing SQL-test cache snapshot directly from native records.
+
+use std::collections::BTreeMap;
+use std::path::Path;
+
+use sqlbuild_core::json::main::dumps::dumps;
+use sqlbuild_core::json::models::{JsonDialect, JsonValue, StdlibJsonOptions};
+
+use crate::artifacts::constants::{SQL_TEST_CACHE_FILE, SQL_TEST_CACHE_VERSION};
+use crate::artifacts::models::SqlTestArtifactRecord;
+
+/// Atomically replace the snapshot with Python-compatible JSON; write failures are cache misses.
+pub fn write_sql_test_cache(directory: &Path, records: &[(String, SqlTestArtifactRecord)]) {
+    let rows: BTreeMap<String, JsonValue> = records
+        .iter()
+        .map(|(key, record)| {
+            let fields = JsonValue::Object(vec![
+                (
+                    "identity".to_owned(),
+                    JsonValue::String(record.identity.clone()),
+                ),
+                (
+                    "relative_path".to_owned(),
+                    JsonValue::String(record.relative_posix()),
+                ),
+                ("size".to_owned(), JsonValue::Integer(record.size.into())),
+                (
+                    "mtime_ns".to_owned(),
+                    JsonValue::Integer(record.mtime_ns.into()),
+                ),
+                (
+                    "content_sha256".to_owned(),
+                    JsonValue::String(record.content_sha256.clone()),
+                ),
+            ]);
+            (key.clone(), fields)
+        })
+        .collect();
+    let payload = JsonValue::Object(vec![
+        (
+            "version".to_owned(),
+            JsonValue::Integer(SQL_TEST_CACHE_VERSION.into()),
+        ),
+        (
+            "records".to_owned(),
+            JsonValue::Object(rows.into_iter().collect()),
+        ),
+    ]);
+    let Ok(encoded) = dumps(
+        &payload,
+        &JsonDialect::Stdlib(StdlibJsonOptions {
+            sort_keys: true,
+            ..StdlibJsonOptions::new(None).with_separators(",", ":")
+        }),
+    ) else {
+        return;
+    };
+    let temporary = directory.join(format!(".{SQL_TEST_CACHE_FILE}.{}.tmp", std::process::id()));
+    let _ = (|| -> std::io::Result<()> {
+        std::fs::create_dir_all(directory)?;
+        std::fs::write(&temporary, encoded.as_bytes())?;
+        std::fs::rename(&temporary, directory.join(SQL_TEST_CACHE_FILE))
+    })();
+}

{sqlbuild_cli-0.186.1 → sqlbuild_cli-0.186.2}/crates/sqlbuild-cache/src/artifacts/models.rs

@@ -59,17 +59,6 @@ impl SqlTestRecordMiss {
     }
 }
 
-/// The fields of one cache file record, already checked to be strings and non-negative integers.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct StoredSqlTestRecord {
-    pub identity: String,
-    /// The `relative_path` text as stored.
-    pub relative_path: String,
-    pub size: u64,
-    pub mtime_ns: i64,
-    pub content_sha256: String,
-}
-
 impl SqlTestArtifactRecord {
     /// The relative path's `as_posix()` text, as the cache file stores it.
     #[must_use]