Function write_change_to_graph

atomic-repository/src/apply/mod.rs:229–385

Write a change to the graph and add it to a view's change log. This function handles two cases: 1. **New change**: The change hasn't been applied to the graph yet. We apply all hunks and add it to the view's change log. 2. **Existing change**: The change is already in the graph (applied via another view). We skip hunk application and just add it to the view's change log. This distinction is cruc

(
    txn: &mut WriteTxn<'_>,
    view_name: &str,
    change_id: NodeId,
    change_hash: &Hash,
    change: &Change,
    options: &InsertOptions,
    already_in_graph: bool,
)

///
/// The result of the insertion including new state and conflict info.
pub fn write_change_to_graph(
    txn: &mut WriteTxn<'_>,
    view_name: &str,
    change_id: NodeId,
    change_hash: &Hash,
    change: &Change,
    options: &InsertOptions,
    already_in_graph: bool,
) -> InsertResult<InsertOutcome> {
    let mut workspace = Workspace::new();
    let mut conflict_tracker = ConflictTracker::new();
    let mut stats = InsertStats::new();
    let trace_record = std::env::var_os("ATOMIC_TRACE_RECORD").is_some()
        || std::env::var_os("ATOMIC_TRACE_INSERT").is_some();

    // Get the current view
    let mut view = txn
        .open_or_create_view(view_name)
        .map_err(|e| InsertError::Database(e.to_string()))?;

    // Validate we can apply (unless caller explicitly skipped validation,
    // e.g. rebuild_change_graph re-applying an existing change with new hunks).
    if !options.skip_validation {
        validate_can_apply(txn, &view, change_id, change_hash, change)?;
    }

    // Only apply hunks if the change isn't already in the graph.
    // All edges go to the global GRAPH + INODE_GRAPH tables.
    let should_apply_hunks = !already_in_graph;

    log::debug!(
        "write_change_to_graph: change_id={:?} hash={} should_apply_hunks={} view_kind={:?}",
        change_id,
        change_hash.to_base32(),
        should_apply_hunks,
        view.kind
    );

    if should_apply_hunks {
        let hunks = change.hunks();
        let total_hunks = hunks.len();
        let hunk_phase_start = std::time::Instant::now();
        // Open GRAPH + INODE_GRAPH once for the whole hunk pass. All graph
        // reads and writes flow through this cached handle, so the tables are
        // opened twice per change instead of ~6 times per hunk. The scope ends
        // before the FileOps/view-update phase, which needs `&mut txn` again.
        {
            let mut cached = CachedWriteGraphTxn::new(&*txn)
                .map_err(|e| InsertError::Database(e.to_string()))?;
            for (hunk_idx, graph_op) in hunks.iter().enumerate() {
                if trace_record && (hunk_idx == 0 || (hunk_idx + 1) % 1_000 == 0) {
                    eprintln!(
                        "[write_change_to_graph] applying hunk {}/{} elapsed={:?}",
                        hunk_idx + 1,
                        total_hunks,
                        hunk_phase_start.elapsed()
                    );
                }