Method insert_unresolved_refs

src/db/unresolved.rs:36–74

Inserts a batch of unresolved references using a prepared statement.

(&self, refs: &[UnresolvedRef])

    /// Inserts a batch of unresolved references using a prepared statement.
    pub async fn insert_unresolved_refs(&self, refs: &[UnresolvedRef]) -> Result<()> {
        if refs.is_empty() {
            return Ok(());
        }

        self.with_batch_transaction("insert_unresolved_refs", async {
            let stmt = self.conn()
                .prepare("INSERT INTO unresolved_refs (from_node_id,reference_name,reference_kind,line,col,file_path) VALUES (?1,?2,?3,?4,?5,?6)")
                .await
                .map_err(|e| TraceDecayError::Database {
                    message: format!("failed to prepare: {e}"),
                    operation: "insert_unresolved_refs".to_string(),
                })?;

            for uref in refs {
                if let Err(e) = stmt
                    .execute(params![
                        uref.from_node_id.as_str(),
                        uref.reference_name.as_str(),
                        uref.reference_kind.as_str(),
                        i64::from(uref.line),
                        i64::from(uref.column),
                        uref.file_path.as_str(),
                    ])
                    .await
                {
                    stmt.reset();
                    return Err(TraceDecayError::Database {
                        message: format!("failed to insert unresolved ref: {e}"),
                        operation: "insert_unresolved_refs".to_string(),
                    });
                }
                stmt.reset();
            }

            Ok(())
        })
        .await
    }

    /// Returns all unresolved references.
    pub async fn get_unresolved_refs(&self) -> Result<Vec<UnresolvedRef>> {