Method apply_diff

sdks/rust/src/client_cache.rs:269–302

Apply all the deletes and inserts recorded in `diff`. Return a [`TableAppliedDiff`] which encodes the actual changes to rows present or deleted after taking into account rows' refcounts. The resulting [`TableAppliedDiff`] will contain only deletes and inserts. Its `update_deletes` and `update_inserts` fields will be empty. The caller should use [`TableAppliedDiff::with_updates_by_pk`] to merge de

(&mut self, diff: &'r TableUpdate<Row>)

    /// The caller should use [`TableAppliedDiff::with_updates_by_pk`] to merge delete/insert pairs
    /// and populate the `update_*` fields.
    fn apply_diff<'r>(&mut self, diff: &'r TableUpdate<Row>) -> TableAppliedDiff<'r, Row> {
        // Apply all inserts and collect all `ref_count: 0 -> 1` events.
        // Inserts must be applied before deletes to avoid the panic in `handle_delete`
        // and to avoid duplicate index insertion errors.
        let mut insert_events = <_>::default();
        for insert in &diff.inserts {
            self.handle_insert(&mut insert_events, insert);
        }

        // Apply all deletes and collect all `ref_count -> 0` events.
        let mut delete_events = <_>::default();
        for delete in &diff.deletes {
            self.handle_delete(&mut insert_events, &mut delete_events, delete);
        }

        // Update indices.
        // We apply deletes first to make space for later insertions
        // and to avoid duplicates in any unique index.
        for index in self.unique_indices.values_mut() {
            for row in delete_events.values() {
                index.remove_row(row);
            }
            for &row in insert_events.values() {
                index.add_row(row.clone());
            }
        }

        TableAppliedDiff {
            deletes: delete_events,
            inserts: insert_events,
            update_deletes: Vec::new(),
            update_inserts: Vec::new(),
        }
    }

    fn find_by_unique_index<'this>(
        &'this self,