Method insert_change_rec

atomic-repository/src/repository/insert.rs:1914–2034

Insert a change with automatic dependency resolution. This method attempts to insert a change and all its missing dependencies. Dependencies are inserted in topological order (dependencies before dependents). # Arguments `hash` - The hash of the change to insert `options` - Options controlling insertion behavior # Returns An `InsertOutcome` containing aggregate statistics for all inserted cha

(
        &self,
        hash: &Hash,
        options: InsertOptions,
    )

    /// println!("Inserted {} changes", result.stats.changes_applied);
    /// ```
    pub fn insert_change_rec(
        &self,
        hash: &Hash,
        options: InsertOptions,
    ) -> Result<InsertOutcome, RepositoryError> {
        let trace_insert = std::env::var_os("ATOMIC_TRACE_INSERT").is_some();
        let t0 = std::time::Instant::now();

        // Load the target change to get its dependencies
        let _change = self.load_change(hash)?;

        // Get the view name
        let view_name = options.view.as_deref().unwrap_or(&self.current_view);

        if trace_insert {
            eprintln!(
                "[insert_change_rec] start hash={} view={}",
                &hash.to_base32()[..12],
                view_name,
            );
        }

        // Get a read transaction to check what's already inserted
        let read_txn = self
            .pristine
            .read_txn()
            .map_err(|e| RepositoryError::Database(e.to_string()))?;

        let view = read_txn
            .get_view(view_name)
            .map_err(|e| RepositoryError::Database(e.to_string()))?
            .ok_or_else(|| RepositoryError::ViewNotFound {
                name: view_name.to_string(),
            })?;

        // Collect all needed changes (including the target)
        let mut to_insert = Vec::new();
        let mut visited = std::collections::HashSet::new();
        let mut queue = std::collections::VecDeque::new();
        queue.push_back(*hash);

        while let Some(current_hash) = queue.pop_front() {
            if visited.contains(&current_hash) {
                continue;
            }
            visited.insert(current_hash);

            // Check if already inserted
            if let Ok(Some(id)) = read_txn.get_internal(&current_hash) {
                if read_txn.get_change_seq(&view, id).ok().flatten().is_some() {
                    continue; // Already inserted
                }
            }

            // Load and queue dependencies
            let dep_change = self.load_change(&current_hash)?;
            for dep in dep_change.dependencies() {
                if !visited.contains(dep) {