linkrs-sync 0.1.0

Synchronization primitives for Linkrs
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ChangeType {
    Insert,
    Update,
    Delete,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct IndexOpKey {
    pub space_id: u64,
    pub tag_name: String,
    pub field_name: String,
}

impl IndexOpKey {
    pub fn new(space_id: u64, tag_name: impl Into<String>, field_name: impl Into<String>) -> Self {
        Self {
            space_id,
            tag_name: tag_name.into(),
            field_name: field_name.into(),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum IndexType {
    Fulltext,
    Vector,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum IndexData {
    Fulltext(String),
    Vector(Vec<f32>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IndexOperation {
    pub key: IndexOpKey,
    pub index_type: IndexType,
    pub change_type: ChangeType,
    pub id: String,
    pub data: Option<IndexData>,
}

impl IndexOperation {
    pub fn new_fulltext(
        key: IndexOpKey,
        change_type: ChangeType,
        id: impl Into<String>,
        text: Option<String>,
    ) -> Self {
        Self {
            key,
            index_type: IndexType::Fulltext,
            change_type,
            id: id.into(),
            data: text.map(IndexData::Fulltext),
        }
    }

    pub fn new_vector(
        key: IndexOpKey,
        change_type: ChangeType,
        id: impl Into<String>,
        vector: Option<Vec<f32>>,
    ) -> Self {
        Self {
            key,
            index_type: IndexType::Vector,
            change_type,
            id: id.into(),
            data: vector.map(IndexData::Vector),
        }
    }

    pub fn extract_index_key(&self) -> (u64, String, String) {
        (
            self.key.space_id,
            self.key.tag_name.clone(),
            self.key.field_name.clone(),
        )
    }

    pub fn space_id(&self) -> u64 {
        self.key.space_id
    }

    pub fn tag_name(&self) -> &str {
        &self.key.tag_name
    }

    pub fn field_name(&self) -> &str {
        &self.key.field_name
    }

    pub fn text(&self) -> Option<&str> {
        match &self.data {
            Some(IndexData::Fulltext(text)) => Some(text),
            Some(IndexData::Vector(_)) | None => None,
        }
    }

    pub fn vector(&self) -> Option<&[f32]> {
        match &self.data {
            Some(IndexData::Vector(vector)) => Some(vector),
            Some(IndexData::Fulltext(_)) | None => None,
        }
    }
}