cartel-sqlite 0.29.0

SQLite driver for the dope runtime
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::{api::batches, row};

#[doc(hidden)]
pub struct Plain;

#[doc(hidden)]
pub struct Arena;

#[doc(hidden)]
pub struct ArenaState<'arena, T: Copy + 'arena> {
    retainer: row::raw::Retainer<'arena, T>,
    plain: Plain,
}

#[doc(hidden)]
pub struct Input<'query, 'owner: 'query> {
    arena: &'query mut batches::Arena<'owner>,
}

/// A static retention layout selected by one `Decode` implementation.
#[doc(hidden)]
pub trait Kind: Sized {
    type With<K: Kind>: Kind;
    type Init<'query, 'owner: 'query>;
    type State<'arena, T: Copy + 'arena>;

    fn init<'query, 'owner: 'query>(input: Input<'query, 'owner>) -> Self::Init<'query, 'owner>;

    fn start<'query, 'owner: 'query, T: Copy + 'query>(
        init: Self::Init<'query, 'owner>,
        rows: usize,
    ) -> Result<Self::State<'query, T>, crate::Error>;

    fn from_arena<'borrow, 'arena, T: Copy + 'arena>(
        state: &'borrow mut ArenaState<'arena, T>,
    ) -> &'borrow mut Self::State<'arena, T>;
}

#[doc(hidden)]
pub trait Contains<K: Kind>: Kind {
    fn get<'borrow, 'arena, T: Copy + 'arena>(
        state: &'borrow mut Self::State<'arena, T>,
    ) -> &'borrow mut K::State<'arena, T>;
}

impl<'query, 'owner: 'query> Input<'query, 'owner> {
    pub(crate) const fn new(arena: &'query mut batches::Arena<'owner>) -> Self {
        Self { arena }
    }
}

impl Kind for Plain {
    type With<K: Kind> = K;
    type Init<'query, 'owner: 'query> = Self;
    type State<'arena, T: Copy + 'arena> = Self;

    fn init<'query, 'owner: 'query>(_input: Input<'query, 'owner>) -> Self::Init<'query, 'owner> {
        Self
    }

    fn start<'query, 'owner: 'query, T: Copy + 'query>(
        init: Self::Init<'query, 'owner>,
        _rows: usize,
    ) -> Result<Self::State<'query, T>, crate::Error> {
        Ok(init)
    }

    fn from_arena<'borrow, 'arena, T: Copy + 'arena>(
        state: &'borrow mut ArenaState<'arena, T>,
    ) -> &'borrow mut Self::State<'arena, T> {
        &mut state.plain
    }
}

impl Kind for Arena {
    type With<K: Kind> = Self;
    type Init<'query, 'owner: 'query> = Input<'query, 'owner>;
    type State<'arena, T: Copy + 'arena> = ArenaState<'arena, T>;

    fn init<'query, 'owner: 'query>(input: Input<'query, 'owner>) -> Self::Init<'query, 'owner> {
        input
    }

    fn start<'query, 'owner: 'query, T: Copy + 'query>(
        init: Self::Init<'query, 'owner>,
        rows: usize,
    ) -> Result<Self::State<'query, T>, crate::Error> {
        Ok(ArenaState {
            retainer: row::raw::Retainer::new(init.arena, rows)?,
            plain: Plain,
        })
    }

    fn from_arena<'borrow, 'arena, T: Copy + 'arena>(
        state: &'borrow mut ArenaState<'arena, T>,
    ) -> &'borrow mut Self::State<'arena, T> {
        state
    }
}

impl Contains<Plain> for Plain {
    fn get<'borrow, 'arena, T: Copy + 'arena>(
        state: &'borrow mut Self::State<'arena, T>,
    ) -> &'borrow mut <Plain as Kind>::State<'arena, T> {
        state
    }
}

impl Contains<Plain> for Arena {
    fn get<'borrow, 'arena, T: Copy + 'arena>(
        state: &'borrow mut Self::State<'arena, T>,
    ) -> &'borrow mut <Plain as Kind>::State<'arena, T> {
        &mut state.plain
    }
}

impl Contains<Arena> for Arena {
    fn get<'borrow, 'arena, T: Copy + 'arena>(
        state: &'borrow mut Self::State<'arena, T>,
    ) -> &'borrow mut <Arena as Kind>::State<'arena, T> {
        state
    }
}

impl<'arena, T: Copy> ArenaState<'arena, T> {
    pub(crate) fn retainer(&mut self) -> &mut row::raw::Retainer<'arena, T> {
        &mut self.retainer
    }

    pub(crate) fn push(&mut self, value: T) -> Result<(), crate::Error> {
        self.retainer.push(value)
    }

    pub(crate) fn finish(self) -> &'arena [T] {
        self.retainer.finish()
    }
}