p2panda-store 0.6.1

Database traits and SQLite implementations for p2panda
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

// SPDX-License-Identifier: MIT OR Apache-2.0

use p2panda_core::cbor::decode_cbor;
use p2panda_core::{Hash, HashError, LogId, SeqNum};
use sqlx::FromRow;

use crate::sqlite::{DecodeError, SqliteError};

/// Database representation of the sum of all header and body byte size.
#[derive(FromRow, Debug, Clone, PartialEq, Eq)]
pub struct LogMetaRow {
    pub total_header_bytes: String,
    pub total_payload_bytes: String,
    pub total_operation_count: String,
}

impl TryFrom<LogMetaRow> for (u64, u64, u64) {
    type Error = SqliteError;

    fn try_from(row: LogMetaRow) -> Result<Self, Self::Error> {
        let total_header_bytes: u64 = row
            .total_header_bytes
            .parse()
            .map_err(|_| SqliteError::Decode("header size".to_string(), DecodeError::FromStr))?;
        let total_payload_bytes: u64 = row
            .total_payload_bytes
            .parse()
            .map_err(|_| SqliteError::Decode("payload size".to_string(), DecodeError::FromStr))?;
        let total_operation_count: u64 = row.total_operation_count.parse().map_err(|_| {
            SqliteError::Decode("operation count".to_string(), DecodeError::FromStr)
        })?;

        Ok((
            total_header_bytes,
            total_payload_bytes,
            total_operation_count,
        ))
    }
}

/// Database representation of the hash and sequence number of the latest
/// operation in a log.
#[derive(FromRow, Debug, Clone, PartialEq, Eq)]
pub struct LatestEntryRow {
    hash: String,
    seq_num: String,
}

impl TryFrom<LatestEntryRow> for (Hash, SeqNum) {
    type Error = SqliteError;

    fn try_from(row: LatestEntryRow) -> Result<Self, Self::Error> {
        let hash = row
            .hash
            .parse()
            .map_err(|err: HashError| SqliteError::Decode("hash".to_string(), err.into()))?;
        let seq_num = row
            .seq_num
            .parse()
            .map_err(|_| SqliteError::Decode("seq num".to_string(), DecodeError::FromStr))?;

        Ok((hash, seq_num))
    }
}

/// Database representation of a log ID and sequence number for a single operation.
#[derive(FromRow, Debug, Clone, PartialEq, Eq)]
pub struct LogHeightRow {
    pub(crate) log_id: Vec<u8>,
    pub(crate) seq_num: String,
}

impl<L> TryFrom<LogHeightRow> for (L, SeqNum)
where
    L: LogId,
{
    type Error = SqliteError;

    fn try_from(row: LogHeightRow) -> Result<Self, Self::Error> {
        let log_id = decode_cbor(&row.log_id[..])
            .map_err(|err| SqliteError::Decode("log id".to_string(), err.into()))?;
        let seq_num = row
            .seq_num
            .parse()
            .map_err(|_| SqliteError::Decode("seq num".to_string(), DecodeError::FromStr))?;

        Ok((log_id, seq_num))
    }
}