feat: add an analysis of affected store paths if we delete the proposed nixos images

README.md

@@ -16,6 +16,8 @@ configs:
     data_files: datasets/narinfos-2026-01-06T01-13Z.parquet
   - config_name: narinfos in the inventory - nixos images only
     data_files: datasets/narinfos-nixos-images-2026-01-06T01-13Z.parquet
+  - config_name: store paths affected by the removal of nixos images
+    data_files: datasets/narinfos-nixos-images-dangling-refs-2026-01-06T01-13Z.parquet
   - config_name: buildstepoutputs
     data_files: datasets/buildstepoutputs-2025-12-05-17:38:30Z.csv.zst
   - config_name: narinfos in inventory but not in buildstepoutputs
@@ -180,6 +182,13 @@ they are stored elsewhere.
 
 It was compiled using `./duckdb/nixos-images.sql`;
 
+### `datasets/narinfos-nixos-images-dangling-refs-2026-01-06T01-13Z.parquet`
+
+This is a list of store paths which reference one or more of the store paths contained in `datasets/narinfos-nixos-images-2026-01-06T01-13Z.parquet`,
+which will be affected by their removal from https://cache.nixos.org.
+
+It was compiled using `bin/dangling-references.py`.
+
 ### `datasets/buildstepoutputs-2025-12-05-17:38:30Z.csv.zst`
 
 This is a dump of the `buildstepoutputs` table taken from [Hydra] on `2025-12-05T17:38:30Z`. It can be thought of as a

bin/dangling-references.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env nix-shell
+#!nix-shell -i python3 -p "python3.withPackages (ps: [ps.pyarrow])"
+"""
+Dangling References Analysis
+
+Usage: ./bin/dangling-references.py
+"""
+
+import pyarrow.parquet as pq
+import pyarrow as pa
+from pathlib import Path
+import time
+import sys
+import multiprocessing as mp
+
+NUM_WORKERS = 10
+BATCH_SIZE = 50_000
+WRITE_BATCH_SIZE = 10_000  # Write to parquet every N results
+
+OUTPUT_SCHEMA = pa.schema([
+    ("hash", pa.binary()),
+    ("pname", pa.string()),
+    ("dangling_refs", pa.list_(pa.binary())),
+])
+
+def process_row_groups(args):
+    """Stream through assigned row groups, send results to queue."""
+    main_file, row_group_indices, deletion_set, result_queue = args
+
+    processed = 0
+    found = 0
+
+    parquet_file = pq.ParquetFile(main_file)
+
+    for batch in parquet_file.iter_batches(
+        batch_size=BATCH_SIZE,
+        columns=["hash", "pname", "references"],
+        row_groups=row_group_indices
+    ):
+        hashes = batch.column("hash").to_pylist()
+        pnames = batch.column("pname").to_pylist()
+        refs_list = batch.column("references").to_pylist()
+
+        batch_results = []
+        for row_hash, pname, refs in zip(hashes, pnames, refs_list):
+            if row_hash in deletion_set:
+                # this entry is being deleted anyway
+                continue
+            if not refs:
+                # this entry has no refs
+                continue
+
+            # check for any references which point to an entry that will be deleted
+            dangling_refs = [ref for ref in refs if ref in deletion_set]
+            if dangling_refs:
+                # this entry will be affected by one or more of the deleted entries
+                # add to output file
+                batch_results.append((row_hash, pname, dangling_refs))
+
+        if batch_results:
+            # append to queue
+            result_queue.put(batch_results)
+            found += len(batch_results)
+
+        processed += len(hashes)
+
+    return processed, found
+
+
+def writer_process(result_queue, output_file, num_workers):
+    """Receive results from queue and write to parquet incrementally."""
+    writer = None
+    total_written = 0
+    buffer = []
+    workers_done = 0
+
+    while workers_done < num_workers:
+        item = result_queue.get()
+
+        if item is None:
+            # Sentinel: one worker finished
+            workers_done += 1
+            continue
+
+        buffer.extend(item)
+
+        # Write when buffer is large enough
+        if len(buffer) >= WRITE_BATCH_SIZE:
+            table = pa.Table.from_pydict(
+                {
+                    "hash": [r[0] for r in buffer],
+                    "pname": [r[1] for r in buffer],
+                    "dangling_refs": [r[2] for r in buffer],
+                },
+                schema=OUTPUT_SCHEMA
+            )
+            if writer is None:
+                writer = pq.ParquetWriter(output_file, OUTPUT_SCHEMA, compression="zstd")
+            writer.write_table(table)
+            total_written += len(buffer)
+            buffer = []
+
+    # Write remaining buffer
+    if buffer:
+        table = pa.Table.from_pydict(
+            {
+                "hash": [r[0] for r in buffer],
+                "pname": [r[1] for r in buffer],
+                "dangling_refs": [r[2] for r in buffer],
+            },
+            schema=OUTPUT_SCHEMA
+        )
+        if writer is None:
+            writer = pq.ParquetWriter(output_file, OUTPUT_SCHEMA, compression="zstd")
+        writer.write_table(table)
+        total_written += len(buffer)
+
+    if writer:
+        writer.close()
+    else:
+        # No results - write empty file
+        pq.write_table(pa.table({}, schema=OUTPUT_SCHEMA), output_file)
+
+    return total_written
+
+
+def worker_wrapper(args):
+    """Wrapper that sends sentinel when done."""
+    main_file, row_group_indices, deletion_set, result_queue = args
+    processed, found = process_row_groups(args)
+    result_queue.put(None)  # Sentinel
+    return processed, found
+
+
+def main():
+    base = Path("datasets")
+    main_file = base / "narinfos-2026-01-06T01-13Z.parquet"
+    deletion_file = base / "narinfos-nixos-images-2026-01-06T01-13Z.parquet"
+    output_file = base / "narinfos-nixos-images-dangling-refs-2026-01-06T01-13Z.parquet"
+
+    # Step 1: Load deletion hashes
+    print("Loading deletion set...")
+    start = time.time()
+    deletion_table = pq.read_table(deletion_file, columns=["hash"])
+    deletion_set = frozenset(h.as_py() for h in deletion_table.column("hash"))
+    del deletion_table
+    print(f"  Loaded {len(deletion_set):,} deletion hashes in {time.time()-start:.1f}s")
+
+    # Step 2: Get row group info
+    parquet_file = pq.ParquetFile(main_file)
+    num_row_groups = parquet_file.metadata.num_row_groups
+    total_rows = parquet_file.metadata.num_rows
+    print(f"  Total: {total_rows:,} rows in {num_row_groups} row groups")
+
+    # Distribute row groups across workers
+    workers = min(NUM_WORKERS, num_row_groups)
+    row_groups_per_worker = [[] for _ in range(workers)]
+    for i in range(num_row_groups):
+        row_groups_per_worker[i % workers].append(i)
+
+    # Create queue for results
+    manager = mp.Manager()
+    result_queue = manager.Queue()
+
+    # Start writer process
+    writer_proc = mp.Process(
+        target=writer_process,
+        args=(result_queue, str(output_file), workers)
+    )
+    writer_proc.start()
+
+    # Prepare worker args
+    worker_args = [
+        (str(main_file), rgs, deletion_set, result_queue)
+        for rgs in row_groups_per_worker
+    ]
+
+    # Step 3: Process in parallel
+    print(f"Processing with {workers} workers (batch size {BATCH_SIZE:,})...")
+    print(f"  Streaming results to {output_file}")
+    sys.stdout.flush()
+    start = time.time()
+
+    with mp.Pool(workers) as pool:
+        worker_results = pool.map(worker_wrapper, worker_args)
+
+    # Wait for writer to finish
+    writer_proc.join()
+
+    # Aggregate stats
+    total_processed = sum(r[0] for r in worker_results)
+    total_found = sum(r[1] for r in worker_results)
+
+    elapsed = time.time() - start
+    print(f"  Completed in {elapsed:.1f}s ({elapsed/60:.1f} min)")
+    print(f"  Rate: {total_processed/elapsed:,.0f} rows/sec")
+
+    # Summary
+    print("\n" + "="*50)
+    print("SUMMARY")
+    print("="*50)
+    print(f"Entries with dangling refs: {total_found:,}")
+
+    if total_found > 0:
+        # Read back sample for display
+        result_table = pq.read_table(output_file)
+
+        # Sample up to 50 entries evenly across the output
+        num_rows = len(result_table)
+        sample_count = min(50, num_rows)
+        step = max(1, num_rows // sample_count)
+        sample_indices = [i * step for i in range(sample_count) if i * step < num_rows]
+
+        print(f"\nSample pnames with dangling refs ({len(sample_indices)} of {num_rows:,}):")
+        for i in sample_indices:
+            pname = result_table.column("pname")[i].as_py()
+            num_refs = len(result_table.column("dangling_refs")[i].as_py())
+            print(f"  {pname}: {num_refs} dangling ref(s)")
+    else:
+        print("No dangling references found")
+
+
+if __name__ == "__main__":
+    main()

datasets/narinfos-nixos-images-dangling-refs-2026-01-06T01-13Z.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:633929171cf5032f11b163bd7b8e45756f7c500111d5016f3afb62ee1212a76d
+size 4816554