Method append_session_turn

atomic-core/src/pristine/txn/write/mod.rs:363–401

Append a turn without touching prior rows when the existing session was already written with the current canonical schema.

(
        &mut self,
        mut record: crate::change::session::SessionRecord,
        turn: crate::change::session::SessionTurn,
        existing_turns: &[crate::change::session::SessionTurn],
    )

    /// Append a turn without touching prior rows when the existing session was
    /// already written with the current canonical schema.
    fn append_session_turn(
        &mut self,
        mut record: crate::change::session::SessionRecord,
        turn: crate::change::session::SessionTurn,
        existing_turns: &[crate::change::session::SessionTurn],
    ) -> PristineResult<()> {
        use crate::change::session::{encode_session_turn_key, session_turn_namespace};

        let key =
            encode_session_turn_key(session_turn_namespace(&record.session_id), turn.turn_number);
        {
            let mut turns = self.txn.open_table(SESSION_TURNS)?;
            let mut reverse = self.txn.open_table(SESSION_PROVENANCE)?;
            let bytes = turn.to_bytes();
            turns.insert(&key, bytes.as_slice())?;
            reverse.insert(turn.provenance_hash.as_bytes(), &key)?;
        }

        if record.first_provenance.is_none() {
            record.first_provenance = Some(turn.provenance_hash);
        }
        record.latest_provenance = Some(turn.provenance_hash);
        record.turn_count = turn.turn_number.saturating_add(1);
        record.started_at = record.started_at.min(turn.timestamp);
        {
            let mut sessions = self.txn.open_table(SESSIONS)?;
            let bytes = record.to_bytes();
            sessions.insert(record.session_id.as_str(), bytes.as_slice())?;
        }

        let previous_turn_number = turn.previous_provenance.and_then(|hash| {
            existing_turns
                .iter()
                .find(|existing| existing.provenance_hash == hash)
                .map(|existing| existing.turn_number)
                .or_else(|| (hash == turn.provenance_hash).then_some(turn.turn_number))
        });
        self.emit_turn_kg(&record, &turn, previous_turn_number)
    }

    fn index_session_turn_candidate(
        &mut self,