Method insert_nodes

src/db/nodes.rs:242–304

Inserts nodes using a prepared statement: parse SQL once, then bind+execute+reset for each row — zero SQL parsing after the first call.

(&self, nodes: &[Node])

    /// Inserts nodes using a prepared statement: parse SQL once, then
    /// bind+execute+reset for each row — zero SQL parsing after the first call.
    pub async fn insert_nodes(&self, nodes: &[Node]) -> Result<()> {
        if nodes.is_empty() {
            return Ok(());
        }

        self.with_batch_transaction("insert_nodes", async {
            let stmt = self.conn()
                .prepare(
                    "INSERT OR REPLACE INTO nodes \
                     (id,kind,name,qualified_name,file_path,\
                     start_line,end_line,start_column,end_column,\
                     docstring,signature,visibility,is_async,\
                     branches,loops,returns,max_nesting,\
                     unsafe_blocks,unchecked_calls,assertions,updated_at,attrs_start_line,parent_id) \
                     VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15,?16,?17,?18,?19,?20,?21,?22,?23)"
                )
                .await
                .map_err(|e| TraceDecayError::Database {
                    message: format!("failed to prepare: {e}"),
                    operation: "insert_nodes".to_string(),
                })?;

            for node in nodes {
                let params = params![
                    node.id.as_str(),
                    node.kind.as_str(),
                    node.name.as_str(),
                    node.qualified_name.as_str(),
                    node.file_path.as_str(),
                    i64::from(node.start_line),
                    i64::from(node.end_line),
                    i64::from(node.start_column),
                    i64::from(node.end_column),
                    opt_str(node.docstring.as_deref()),
                    opt_str(node.signature.as_deref()),
                    node.visibility.as_str(),
                    i64::from(node.is_async),
                    i64::from(node.branches),
                    i64::from(node.loops),
                    i64::from(node.returns),
                    i64::from(node.max_nesting),
                    i64::from(node.unsafe_blocks),
                    i64::from(node.unchecked_calls),
                    i64::from(node.assertions),
                    node.updated_at as i64,
                    i64::from(node.attrs_start_line),
                    opt_str(node.parent_id.as_deref()),
                ];
                let insert_result = stmt.execute(params).await;
                if let Err(e) = insert_result {
                    stmt.reset();
                    return Err(TraceDecayError::Database {
                        message: format!("failed to insert node: {e}"),
                        operation: "insert_nodes".to_string(),
                    });
                }
                stmt.reset();
            }