charybdis 1.1.0

High-Performance ORM for ScyllaDB
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

use charybdis::scylla::serialize::writers::CellWriter;
use charybdis::scylla::SerializeValue;
use charybdis::types::Text;
use scylla::deserialize::value::DeserializeValue;
use scylla::deserialize::{DeserializationError, FrameSlice, TypeCheckError};
use scylla::frame::response::result::ColumnType;
use scylla::serialize::writers::WrittenCellProof;
use scylla::serialize::SerializationError;

#[derive(Debug, Default, Clone, PartialEq, strum::FromRepr)]
#[repr(i8)]
pub enum AddressTypeCustomField {
    #[default]
    HomeAddress = 0,
    WorkAddress = 1,
}

#[derive(Debug)]
struct AddressTypeCustomDeserializeErr(i8);
impl std::fmt::Display for AddressTypeCustomDeserializeErr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "AddressTypeCustomDeserializeErr({})", self.0)
    }
}
impl std::error::Error for AddressTypeCustomDeserializeErr {}

impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for AddressTypeCustomField {
    fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
        <i8 as DeserializeValue<'frame, 'metadata>>::type_check(typ)
    }

    fn deserialize(
        typ: &'metadata ColumnType<'metadata>,
        v: Option<FrameSlice<'frame>>,
    ) -> Result<Self, DeserializationError> {
        let si8 = <i8 as DeserializeValue<'frame, 'metadata>>::deserialize(typ, v)?;
        let s = Self::from_repr(si8);
        s.ok_or_else(|| DeserializationError::new(AddressTypeCustomDeserializeErr(si8)))
    }
}

impl SerializeValue for AddressTypeCustomField {
    fn serialize<'b>(
        &self,
        typ: &ColumnType,
        writer: CellWriter<'b>,
    ) -> Result<WrittenCellProof<'b>, SerializationError> {
        let disc = self.clone() as i8;

        let v = <i8 as SerializeValue>::serialize(&disc, typ, writer)?;
        Ok(v)
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct UserExtraDataCustomField {
    pub user_tags: Vec<(String, String)>,
}

impl Default for UserExtraDataCustomField {
    fn default() -> Self {
        Self {
            user_tags: vec![("some_key".to_string(), "some_value".to_string())],
        }
    }
}

#[derive(Debug)]
struct UserExtraDataDeserializeErr(String);
impl std::fmt::Display for UserExtraDataDeserializeErr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "UserExtraDataDeserializeErr({})", self.0)
    }
}
impl std::error::Error for UserExtraDataDeserializeErr {}

impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for UserExtraDataCustomField {
    fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
        <Text as DeserializeValue<'frame, 'metadata>>::type_check(typ)
    }

    fn deserialize(
        typ: &'metadata ColumnType<'metadata>,
        v: Option<FrameSlice<'frame>>,
    ) -> Result<Self, DeserializationError> {
        let si8 = <Text as DeserializeValue<'frame, 'metadata>>::deserialize(typ, v)?;
        serde_json::from_str::<UserExtraDataCustomField>(&si8)
            .map_err(|_e| DeserializationError::new(UserExtraDataDeserializeErr(si8)))
    }
}

impl SerializeValue for UserExtraDataCustomField {
    fn serialize<'b>(
        &self,
        typ: &ColumnType,
        writer: CellWriter<'b>,
    ) -> Result<WrittenCellProof<'b>, SerializationError> {
        let disc = serde_json::to_string(&self).map_err(|_e| SerializationError::new(_e))?;

        let v = <Text as SerializeValue>::serialize(&disc, typ, writer)?;
        Ok(v)
    }
}