sqlbuild-cli 0.157.0__tar.gz → 0.157.1__tar.gz

{sqlbuild_cli-0.157.0 → sqlbuild_cli-0.157.1}/Cargo.lock

@@ -1142,7 +1142,7 @@ checksum = "5b3dc8af474f516a851ff4bd12db780f948b9250ad37211e4eec0bccea54e01b"
 
 [[package]]
 name = "sqlbuild-analysis"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "polyglot-sql",
  "polyglot-sql-function-catalogs",
@@ -1164,7 +1164,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-attachments"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "sqlbuild-core",
  "sqlbuild-sqltext",
@@ -1172,7 +1172,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-cache"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "blake3",
  "rayon",
@@ -1185,7 +1185,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-cli"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "blake3",
  "ctrlc",
@@ -1200,7 +1200,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-config"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "saphyr-parser",
  "sqlbuild-core",
@@ -1211,7 +1211,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-core"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "regex",
  "sha2",
@@ -1219,14 +1219,14 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-cursor"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "sqlbuild-core",
 ]
 
 [[package]]
 name = "sqlbuild-discovery"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "junction",
  "rayon",
@@ -1239,7 +1239,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-model-config"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "regex",
  "sqlbuild-core",
@@ -1247,7 +1247,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-pysource"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "ruff_python_ast",
  "ruff_python_parser",
@@ -1258,11 +1258,12 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-python"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "fensu-policy",
  "mimalloc",
  "pyo3",
+ "rayon",
  "serde",
  "serde_json",
  "sqlbuild-analysis",
@@ -1285,7 +1286,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-refactor"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "serde",
  "serde_json",
@@ -1299,7 +1300,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-render"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "serde_json",
  "sqlbuild-cache",
@@ -1309,8 +1310,9 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-rules"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
+ "blake3",
  "fensu-policy",
  "globset",
  "polyglot-sql",
@@ -1333,7 +1335,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-scopes"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "serde_json",
  "sha2",
@@ -1346,7 +1348,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-sqltext"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "rayon",
  "serde",
@@ -1356,7 +1358,7 @@ dependencies = [
 
 [[package]]
 name = "sqlbuild-state"
-version = "0.157.0"
+version = "0.157.1"
 dependencies = [
  "serde_json",
  "sha2",

{sqlbuild_cli-0.157.0 → sqlbuild_cli-0.157.1}/Cargo.toml

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

{sqlbuild_cli-0.157.0 → sqlbuild_cli-0.157.1}/PKG-INFO

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

{sqlbuild_cli-0.157.0 → sqlbuild_cli-0.157.1}/crates/sqlbuild-cache/src/artifacts/_helpers/files.rs

@@ -5,6 +5,9 @@ use std::fs::{File, OpenOptions};
 use std::io::{ErrorKind, Read, Write};
 use std::path::{Path, PathBuf};
 
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+
+use crate::artifacts::constants::{PARALLEL_WRITE_MIN_FILES, WRITE_WORKERS};
 use crate::artifacts::errors::ArtifactError;
 use crate::artifacts::models::{Publication, WrittenArtifacts};
 
@@ -19,23 +22,74 @@ pub(crate) fn write_artifacts(
     files: &[(PathBuf, Vec<u8>)],
     check_existing: bool,
 ) -> Result<WrittenArtifacts, ArtifactError> {
+    if files.len() >= PARALLEL_WRITE_MIN_FILES && distinct_paths(files) {
+        return write_artifacts_parallel(files, check_existing);
+    }
     let mut outcome: WrittenArtifacts = WrittenArtifacts::default();
     for (path, contents) in files {
-        if check_existing && let Some(existing) = read_regular_file(path)? {
-            if existing == *contents {
-                outcome.unchanged += 1;
-                continue;
-            }
-            if std::str::from_utf8(&existing).is_err() {
-                return Err(ArtifactError::ExistingNotUtf8 { path: path.clone() });
-            }
+        if write_artifact(path, contents, check_existing)? {
+            outcome.written += 1;
+        } else {
+            outcome.unchanged += 1;
         }
-        overwrite_creating_parent(path, contents)?;
-        outcome.written += 1;
     }
     Ok(outcome)
 }
 
+/// Write distinct files on a small pool; the first failure in file order is the one reported.
+fn write_artifacts_parallel(
+    files: &[(PathBuf, Vec<u8>)],
+    check_existing: bool,
+) -> Result<WrittenArtifacts, ArtifactError> {
+    let write = || -> Vec<Result<bool, ArtifactError>> {
+        files
+            .par_iter()
+            .map(|(path, contents)| write_artifact(path, contents, check_existing))
+            .collect()
+    };
+    let results: Vec<Result<bool, ArtifactError>> = match rayon::ThreadPoolBuilder::new()
+        .num_threads(WRITE_WORKERS)
+        .build()
+    {
+        Ok(pool) => pool.install(write),
+        Err(_) => write(),
+    };
+    let mut outcome: WrittenArtifacts = WrittenArtifacts::default();
+    for result in results {
+        if result? {
+            outcome.written += 1;
+        } else {
+            outcome.unchanged += 1;
+        }
+    }
+    Ok(outcome)
+}
+
+fn distinct_paths(files: &[(PathBuf, Vec<u8>)]) -> bool {
+    let mut seen: HashSet<&Path> = HashSet::with_capacity(files.len());
+    files.iter().all(|(path, _)| seen.insert(path.as_path()))
+}
+
+/// Write one artifact; `false` when a byte-identical existing file was left untouched.
+fn write_artifact(
+    path: &Path,
+    contents: &[u8],
+    check_existing: bool,
+) -> Result<bool, ArtifactError> {
+    if check_existing && let Some(existing) = read_regular_file(path)? {
+        if existing == contents {
+            return Ok(false);
+        }
+        if std::str::from_utf8(&existing).is_err() {
+            return Err(ArtifactError::ExistingNotUtf8 {
+                path: path.to_path_buf(),
+            });
+        }
+    }
+    overwrite_creating_parent(path, contents)?;
+    Ok(true)
+}
+
 /// A regular file's bytes, or `None` when nothing comparable is at `path`.
 fn read_regular_file(path: &Path) -> Result<Option<Vec<u8>>, ArtifactError> {
     let mut file: File = match File::open(path) {

{sqlbuild_cli-0.157.0 → sqlbuild_cli-0.157.1}/crates/sqlbuild-cache/src/artifacts/constants.rs

@@ -4,3 +4,7 @@ pub const NEW_FILE_MODE: u32 = 0o666;
 pub(crate) const SQL_EXTENSION: &str = "sql";
 #[cfg(unix)]
 pub(crate) const NANOS_PER_SECOND: i64 = 1_000_000_000;
+/// Below this many files a sequential write is cheaper than starting a pool.
+pub(crate) const PARALLEL_WRITE_MIN_FILES: usize = 64;
+/// Writer threads for one artifact batch, matching SQL test planning's fixed pool.
+pub(crate) const WRITE_WORKERS: usize = 4;

{sqlbuild_cli-0.157.0 → sqlbuild_cli-0.157.1}/crates/sqlbuild-cache/src/artifacts/mod.rs

@@ -5,3 +5,6 @@ pub mod constants;
 pub mod errors;
 pub mod main;
 pub mod models;
+
+#[cfg(test)]
+mod tests;

sqlbuild_cli-0.157.1/crates/sqlbuild-cache/src/artifacts/tests/helpers.rs

@@ -0,0 +1,19 @@
+use std::path::{Path, PathBuf};
+
+/// `count` distinct SQL artifacts spread over nested directories under `root`.
+pub(crate) fn batch(root: &Path, count: usize) -> Vec<(PathBuf, Vec<u8>)> {
+    (0..count)
+        .map(|index| {
+            (
+                root.join(format!("group_{}/nested/model_{index}.sql", index % 7)),
+                format!("select {index}\n").into_bytes(),
+            )
+        })
+        .collect()
+}
+
+/// Create `path` with `contents`, including its parent directories.
+pub(crate) fn place(path: &Path, contents: &[u8]) {
+    std::fs::create_dir_all(path.parent().expect("artifact parent")).expect("artifact directory");
+    std::fs::write(path, contents).expect("existing artifact");
+}

sqlbuild_cli-0.157.1/crates/sqlbuild-cache/src/artifacts/tests/test_types.rs

@@ -0,0 +1,26 @@
+/// One artifact batch written over a target where some files already exist.
+pub(crate) struct WriteBatchTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) file_count: usize,
+    pub(crate) check_existing: bool,
+    pub(crate) existing_identical: &'static [usize],
+    pub(crate) existing_different: &'static [usize],
+    pub(crate) expected_written: usize,
+    pub(crate) expected_unchanged: usize,
+}
+
+/// One batch with existing non-UTF-8 files at several positions.
+pub(crate) struct FirstFailureTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) file_count: usize,
+    pub(crate) failing: &'static [usize],
+    pub(crate) expected_failing: usize,
+}
+
+/// One batch that queues the same path more than once.
+pub(crate) struct RepeatedPathTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) file_count: usize,
+    pub(crate) repeated: usize,
+    pub(crate) expected_contents: &'static [u8],
+}

sqlbuild_cli-0.157.1/crates/sqlbuild-cache/src/artifacts/tests/test_write_artifacts.rs

@@ -0,0 +1,131 @@
+use crate::artifacts::errors::ArtifactError;
+use crate::artifacts::main::write_artifacts::write_artifacts;
+use crate::artifacts::tests::helpers::{batch, place};
+use crate::artifacts::tests::test_types::{
+    FirstFailureTestCase, RepeatedPathTestCase, WriteBatchTestCase,
+};
+
+#[test]
+fn given_artifact_batch_when_written_then_every_file_matches_and_unchanged_files_are_counted() {
+    let test_cases = [
+        WriteBatchTestCase {
+            description: "small sequential batch",
+            file_count: 5,
+            check_existing: true,
+            existing_identical: &[1],
+            existing_different: &[3],
+            expected_written: 4,
+            expected_unchanged: 1,
+        },
+        WriteBatchTestCase {
+            description: "large parallel batch",
+            file_count: 500,
+            check_existing: true,
+            existing_identical: &[0, 250, 499],
+            existing_different: &[10, 400],
+            expected_written: 497,
+            expected_unchanged: 3,
+        },
+        WriteBatchTestCase {
+            description: "parallel batch overwriting without checks",
+            file_count: 200,
+            check_existing: false,
+            existing_identical: &[5],
+            existing_different: &[6],
+            expected_written: 200,
+            expected_unchanged: 0,
+        },
+        WriteBatchTestCase {
+            description: "parallel batch into an empty target",
+            file_count: 64,
+            check_existing: true,
+            existing_identical: &[],
+            existing_different: &[],
+            expected_written: 64,
+            expected_unchanged: 0,
+        },
+    ];
+    for test_case in test_cases {
+        let root = tempfile::tempdir().expect("target directory");
+        let files = batch(root.path(), test_case.file_count);
+        for &index in test_case.existing_identical {
+            place(&files[index].0, &files[index].1);
+        }
+        for &index in test_case.existing_different {
+            place(&files[index].0, b"stale\n");
+        }
+        let outcome = write_artifacts(&files, test_case.check_existing).expect("written batch");
+        assert_eq!(
+            outcome.written, test_case.expected_written,
+            "{}",
+            test_case.description
+        );
+        assert_eq!(
+            outcome.unchanged, test_case.expected_unchanged,
+            "{}",
+            test_case.description
+        );
+        let matching = files
+            .iter()
+            .filter(|(path, contents)| std::fs::read(path).ok().as_ref() == Some(contents))
+            .count();
+        assert_eq!(matching, test_case.file_count, "{}", test_case.description);
+    }
+}
+
+#[test]
+fn given_several_non_utf8_existing_files_when_written_then_the_first_in_batch_order_is_reported() {
+    let test_cases = [
+        FirstFailureTestCase {
+            description: "sequential batch",
+            file_count: 10,
+            failing: &[3, 9],
+            expected_failing: 3,
+        },
+        FirstFailureTestCase {
+            description: "parallel batch",
+            file_count: 300,
+            failing: &[100, 299],
+            expected_failing: 100,
+        },
+    ];
+    for test_case in test_cases {
+        let root = tempfile::tempdir().expect("target directory");
+        let files = batch(root.path(), test_case.file_count);
+        for &index in test_case.failing {
+            place(&files[index].0, &[0xff, 0xfe]);
+        }
+        let error = write_artifacts(&files, true).expect_err("non-UTF-8 existing artifact");
+        assert!(
+            matches!(
+                &error,
+                ArtifactError::ExistingNotUtf8 { path } if *path == files[test_case.expected_failing].0
+            ),
+            "{}: {error:?}",
+            test_case.description
+        );
+    }
+}
+
+#[test]
+fn given_repeated_artifact_path_when_written_then_the_last_queued_contents_win() {
+    let test_cases = [RepeatedPathTestCase {
+        description: "large batch repeating one path",
+        file_count: 100,
+        repeated: 2,
+        expected_contents: b"select 'last'\n",
+    }];
+    for test_case in test_cases {
+        let root = tempfile::tempdir().expect("target directory");
+        let mut files = batch(root.path(), test_case.file_count);
+        let repeated = files[test_case.repeated].0.clone();
+        files.push((repeated.clone(), test_case.expected_contents.to_vec()));
+        write_artifacts(&files, true).expect("written batch");
+        assert_eq!(
+            std::fs::read(&repeated).expect("repeated artifact"),
+            test_case.expected_contents,
+            "{}",
+            test_case.description
+        );
+    }
+}

sqlbuild_cli-0.157.1/crates/sqlbuild-cache/src/artifacts/tests.rs

@@ -0,0 +1,6 @@
+#[path = "tests/helpers.rs"]
+mod helpers;
+#[path = "tests/test_types.rs"]
+mod test_types;
+#[path = "tests/test_write_artifacts.rs"]
+mod write_artifacts;

{sqlbuild_cli-0.157.0 → sqlbuild_cli-0.157.1}/crates/sqlbuild-core/src/compile_timings/constants.rs

@@ -1,7 +1,7 @@
 //! The compile phases and metrics `--json` reports, in presentation order.
 
 /// Phases whose elapsed nanoseconds are reported as whole milliseconds.
-pub const COMPILE_TIMING_PHASES: [&str; 13] = [
+pub const COMPILE_TIMING_PHASES: [&str; 15] = [
     "attachment_ms",
     "model_analysis_ms",
     "model_analysis_cpu_ms",
@@ -15,14 +15,18 @@ pub const COMPILE_TIMING_PHASES: [&str; 13] = [
     "cache_publication_ms",
     "physical_write_ms",
     "stale_traversal_ms",
+    "early_rules_build_ms",
+    "early_rules_wait_ms",
 ];
 
 /// Counters reported as recorded.
-pub const COMPILE_METRICS: [&str; 6] = [
+pub const COMPILE_METRICS: [&str; 8] = [
     "analysis_batch_cache_hits",
     "analysis_entry_cache_hits",
     "analysis_cache_misses",
     "analysis_cache_bypasses",
     "sql_test_scan_cache_hits",
     "sql_test_scan_cache_misses",
+    "early_rules_hits",
+    "early_rules_misses",
 ];

{sqlbuild_cli-0.157.0 → sqlbuild_cli-0.157.1}/crates/sqlbuild-core/src/compile_timings/tests/test_compile_timing_milliseconds.rs

@@ -26,9 +26,9 @@ fn given_recorded_timings_when_reported_then_lists_every_phase_and_metric_in_ord
     ];
     for test_case in test_cases {
         let entries = compile_timing_milliseconds(&test_case.timings);
-        assert_eq!(entries.len(), 19, "{}", test_case.description);
+        assert_eq!(entries.len(), 23, "{}", test_case.description);
         assert_eq!(
-            vec![entries[0], entries[18]],
+            vec![entries[0], entries[20]],
             test_case.expected_entries,
             "{}",
             test_case.description

{sqlbuild_cli-0.157.0 → sqlbuild_cli-0.157.1}/crates/sqlbuild-core/src/posix_path/constants.rs

@@ -6,3 +6,5 @@ pub(crate) const ROOT: &str = "/";
 pub(crate) const DOUBLE_ROOT: &str = "//";
 pub(crate) const CURRENT: &str = ".";
 pub(crate) const SUFFIX_MARK: char = '.';
+/// The parent-directory component `normpath` removes lexically.
+pub(crate) const PARENT: &str = "..";

{sqlbuild_cli-0.157.0 → sqlbuild_cli-0.157.1}/crates/sqlbuild-core/src/posix_path/main/mod.rs

@@ -1,3 +1,4 @@
+pub mod posix_abspath;
 pub mod posix_join;
 pub mod posix_name;
 pub mod posix_parent;

sqlbuild_cli-0.157.1/crates/sqlbuild-core/src/posix_path/main/posix_abspath.rs

@@ -0,0 +1,49 @@
+//! `posixpath.abspath(path)` for a process working directory `cwd`.
+
+use crate::posix_path::constants::{CURRENT, DOUBLE_ROOT, PARENT, ROOT, SEPARATOR};
+
+/// `path` joined to `cwd` when relative, then normalised exactly as `posixpath.normpath` does.
+#[must_use]
+pub fn posix_abspath(cwd: &str, path: &str) -> String {
+    if path.starts_with(SEPARATOR) {
+        return posix_normpath(path);
+    }
+    let joined: String = if cwd.is_empty() || cwd.ends_with(SEPARATOR) {
+        format!("{cwd}{path}")
+    } else {
+        format!("{cwd}{ROOT}{path}")
+    };
+    posix_normpath(&joined)
+}
+
+fn posix_normpath(path: &str) -> String {
+    if path.is_empty() {
+        return CURRENT.to_owned();
+    }
+    let root: &str = if path.starts_with(DOUBLE_ROOT) && !path.starts_with("///") {
+        DOUBLE_ROOT
+    } else if path.starts_with(SEPARATOR) {
+        ROOT
+    } else {
+        ""
+    };
+    let mut kept: Vec<&str> = Vec::new();
+    for part in path.split(SEPARATOR) {
+        if part.is_empty() || part == CURRENT {
+            continue;
+        }
+        let keeps_parent: bool =
+            (root.is_empty() && kept.is_empty()) || kept.last() == Some(&PARENT);
+        if part != PARENT || keeps_parent {
+            kept.push(part);
+        } else if !kept.is_empty() {
+            let _ = kept.pop();
+        }
+    }
+    let normalised: String = format!("{root}{}", kept.join(ROOT));
+    if normalised.is_empty() {
+        CURRENT.to_owned()
+    } else {
+        normalised
+    }
+}