rql 0.5.2

An in-memory pseudo database that provides functionality for managing pseudo-relational tables and their schema
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

/*!

Ways of serializing/deserializing data
*/

use serde::{de::DeserializeOwned, Serialize};
use serde_derive::{Deserialize as Des, Serialize as Ser};

/**

Types of data representations
*/
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Ser, Des)]
pub enum Representation {
    /**

    A binary format that is not tolerant to schema changes

    Use this only if you are absolutely certain that your schema
    will not change.

    Uses [bincode](https://github.com/TyOverby/bincode)
    */
    BinaryStable,
    /**

    A binary format that is tolerant to certain schema changes

    Columns and tables can be added, but not reordered or removed.
    Use serde attributes to enable backward compatibility.

    Uses [MessagePack](https://github.com/3Hren/msgpack-rust)
    */
    BinaryDynamic,
    /**

    A human readable format that is tolerant to most schema changes.

    Columns and tables can be added, reordered, or removed.
    Use serde attributes to enable backward compatibility.

    Uses [YAML](https://github.com/dtolnay/serde-yaml)
    */
    HumanReadable,
}

pub use Representation::*;

impl Representation {
    /// Use this `Representation` to serialize some data
    pub fn serialize<S>(self, data: &S) -> Result<Vec<u8>, String>
    where
        S: Serialize,
    {
        use Representation::*;
        Ok(match self {
            BinaryStable => bincode::serialize(data).map_err(|e| e.to_string())?,
            BinaryDynamic => rmp_serde::to_vec(data).map_err(|e| e.to_string())?,
            HumanReadable => serde_yaml::to_vec(data).map_err(|e| e.to_string())?,
        })
    }
    /// Use thie `Representation` to deserialize some data
    pub fn deserialize<B, D>(self, bytes: B) -> Result<D, String>
    where
        B: AsRef<[u8]>,
        D: DeserializeOwned,
    {
        use Representation::*;
        Ok(match self {
            BinaryStable => bincode::deserialize(bytes.as_ref()).map_err(|e| e.to_string())?,
            BinaryDynamic => rmp_serde::from_slice(bytes.as_ref()).map_err(|e| e.to_string())?,
            HumanReadable => serde_yaml::from_slice(bytes.as_ref()).map_err(|e| e.to_string())?,
        })
    }
}