gchdb 0.2.8

Provides a record abstraction for storing chat records extracted by different chat software, and provides full-text search feature
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

use super::*;

enum RecordExistence {
    Exist(Option<Vec<u8>>),
    NotExist,
}

fn check_record(conn: &SqliteConnection, record: &Record) -> ChatRecordResult<RecordExistence> {
    use schema::records::dsl::*;
    match records
        .filter(
            chat_type
                .eq(&record.chat_type)
                .and(owner_id.eq(&record.owner_id))
                .and(group_id.eq(&record.group_id))
                .and(sender_id.eq(&record.sender_id))
                .and(timestamp.eq(record.timestamp)),
        )
        .select(metadata)
        .get_result(conn)
    {
        Ok(data) => Ok(RecordExistence::Exist(data)),
        Err(DieselError::NotFound) => Ok(RecordExistence::NotExist),
        Err(e) => Err(e.into()),
    }
}

fn update_record(conn: &SqliteConnection, record: &Record) -> ChatRecordResult<usize> {
    use schema::records::dsl::*;
    Ok(update(
        records.filter(
            id.eq(record.id).or(chat_type
                .eq(&record.chat_type)
                .and(owner_id.eq(&record.owner_id))
                .and(group_id.eq(&record.group_id))
                .and(sender_id.eq(&record.sender_id))
                .and(timestamp.eq(record.timestamp))),
        ),
    )
    .set((
        sender_name.eq(&record.sender_name),
        content.eq(&record.content),
        metadata.eq(&record.metadata),
    ))
    .execute(conn)?)
}

fn insert_record(conn: &SqliteConnection, record: &Record) -> ChatRecordResult<usize> {
    Ok(insert_into(records::table).values(record).execute(conn)?)
}

pub fn insert_or_update_record(
    conn: &SqliteConnection,
    recorder: &SqliteChatRecorder,
    record: &Record,
    attachs: &HashMap<String, Vec<u8>>,
    metadata_merger: MetadataMerger<SqliteChatRecorder>,
) -> ChatRecordResult<bool> {
    Ok(
        if let RecordExistence::Exist(old_metadata) = check_record(&conn, &record)? {
            let mut record = record.clone();
            if let Some(metadata) = record.metadata {
                record.metadata = if let Some(old_metadata) = old_metadata {
                    metadata_merger(recorder, attachs, old_metadata, metadata)
                } else {
                    Some(metadata.clone())
                }
            } else {
                record.metadata = old_metadata
            }
            update_record(conn, &record)
        } else {
            insert_record(conn, &record)
        }? == 1,
    )
}

pub fn remove_record(conn: &SqliteConnection, record: &Record) -> ChatRecordResult<usize> {
    use schema::records::{dsl::*, table};
    Ok(delete(table)
        .filter(
            id.eq(record.id).or(chat_type
                .eq(&record.chat_type)
                .and(owner_id.eq(&record.owner_id))
                .and(group_id.eq(&record.group_id))
                .and(timestamp.eq(record.timestamp))),
        )
        .execute(conn)?)
}

pub fn remove_record_by_id(conn: &SqliteConnection, id: i32) -> ChatRecordResult<usize> {
    Ok(delete(records::table)
        .filter(records::id.eq(Some(id)))
        .execute(conn)?)
}

pub fn get_record_id(conn: &SqliteConnection, record: &Record) -> ChatRecordResult<i32> {
    use schema::records::dsl::*;
    Ok(records
        .filter(
            id.eq(record.id).or(chat_type
                .eq(&record.chat_type)
                .and(owner_id.eq(&record.owner_id))
                .and(group_id.eq(&record.group_id))
                .and(timestamp.eq(record.timestamp))),
        )
        .select(id)
        .get_result::<Option<i32>>(conn)?
        .unwrap_or(0))
}