Method loader

src/darkbird/storage_vector.rs:409–462

(&self)

    /// load storage from disk
    #[inline]
    async fn loader(&self) -> Result<(), String> {
        // when storage just open with Disc Copies option it call loader, else it don't call
        let wal = &self.wal_session;

        let mut page_index = 1;

        loop {
            // Get Page
            let mut logfile = match wal.get_page(page_index).await {
                Ok(lf) => lf,
                Err(sess_res) => {
                    if let SessionResult::Err(e) = sess_res {
                        return Err(e.to_string())
                    }

                    return Err("disk_log closed".to_string())
                }
            };

            page_index += 1;

            // Must Call Recover if return Err, remove unwrap()
            let iter = match logfile.iter(..) {
                Ok(iter) => iter,
                Err(e) => {
                    eprintln!("==> {:?}", e);
                    return Err(e.to_string());
                }
            };

            for qline in iter {
                let bytes = match qline {
                    Ok(ql)  => ql,
                    Err(e) => return Err(e.to_string()),
                };

                let query: RQuery<VectorId, Vector> = match bincode::deserialize(&bytes) {
                    Ok(rq) => rq,
                    Err(e) => {
                        return Err(e.to_string());
                    }
                };

                match query {
                    RQuery::Insert(vid, v) => {                        
                        let _ = self.insert(vid, v.0).await;
                    }
                    RQuery::Remove(vid) => {
                        let _ = self.remove(vid).await;
                    }
                }
            }
        }
    }


}