infinite-db 0.2.0

A spatial-graph database using n-dimensional curves and hyperedges for engineering logic.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Bulk record import for translation-scale loads.

use crate::infinitedb_core::address::{DimensionVector, RevisionId, SpaceId};

use super::session::{BulkSessionCore, BulkWriteOptions, BulkWriteResult};
use super::super::InfiniteDb;

/// Bulk insert/delete session for raw records in one space.
///
/// Only one bulk session may be active per [`InfiniteDb`] at a time.
/// Parallelize parsing upstream; use a single thread for `push`.
pub struct BulkRecordImport<'a> {
    session: BulkSessionCore<'a>,
    space: SpaceId,
}

impl<'a> BulkRecordImport<'a> {
    pub fn space(&self) -> SpaceId {
        self.space
    }

    pub fn push(&mut self, point: DimensionVector, data: Vec<u8>) -> std::io::Result<RevisionId> {
        self.session.push_write(self.space, point, data)
    }

    pub fn push_delete(&mut self, point: DimensionVector) -> std::io::Result<RevisionId> {
        self.session.push_tombstone(self.space, point)
    }

    pub fn finish(self) -> std::io::Result<BulkWriteResult> {
        self.session.finish()
    }
}

impl InfiniteDb {
    /// Begin a buffered bulk record import into `space`.
    pub fn begin_record_import(&mut self, space: SpaceId) -> std::io::Result<BulkRecordImport<'_>> {
        self.begin_record_import_with_options(space, BulkWriteOptions::default())
    }

    /// Begin bulk record import with explicit WAL/flush tuning.
    pub fn begin_record_import_with_options(
        &mut self,
        space: SpaceId,
        options: BulkWriteOptions,
    ) -> std::io::Result<BulkRecordImport<'_>> {
        Ok(BulkRecordImport {
            session: BulkSessionCore::begin(self, options)?,
            space,
        })
    }

    /// Import many records in one bulk session.
    pub fn insert_records_bulk<I>(
        &mut self,
        space: SpaceId,
        rows: I,
    ) -> std::io::Result<BulkWriteResult>
    where
        I: IntoIterator<Item = (DimensionVector, Vec<u8>)>,
    {
        let mut import = self.begin_record_import(space)?;
        for (point, data) in rows {
            import.push(point, data)?;
        }
        import.finish()
    }

    /// Tombstone many record addresses in one bulk session.
    pub fn delete_records_bulk<I>(
        &mut self,
        space: SpaceId,
        points: I,
    ) -> std::io::Result<BulkWriteResult>
    where
        I: IntoIterator<Item = DimensionVector>,
    {
        let mut import = self.begin_record_import(space)?;
        for point in points {
            import.push_delete(point)?;
        }
        import.finish()
    }
}