cartel-sqlite 0.20.0

SQLite driver for the dope runtime
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

use crate::{api, catalogs};
use api::{exec, tx};
use dope_fiber::abi;
use dope_runtime::client;
use phase::Phase;
use std::{marker, mem, ptr};

mod lease;
use lease::Lease;
mod phase;
pub(crate) mod raw;

/// An exclusive database capability bound to its installed application scope.
///
#[repr(transparent)]
pub struct Connection<'app, 'local: 'app, 'd: 'local, I: catalogs::Catalog = catalogs::Empty> {
    guard: Lease<'app, 'local, 'd, I>,
}

impl<'app, 'local: 'app, 'd: 'local, I: catalogs::Catalog> Connection<'app, 'local, 'd, I> {
    const LAYOUT: () = {
        let word = mem::size_of::<usize>();
        assert!(mem::size_of::<Self>() == word);
        assert!(mem::align_of::<Self>() == mem::align_of::<usize>());
        assert!(mem::size_of::<Option<Self>>() == word);
    };

    const fn new(guard: Lease<'app, 'local, 'd, I>) -> Self {
        Self { guard }
    }

    pub fn query(&mut self) -> exec::Query<'_, 'local, 'd, I> {
        self.guard.state().query()
    }

    pub fn transaction(
        &mut self,
    ) -> impl abi::Fiber<'d, Output = Result<tx::Transaction<'_, 'local, 'd, I>, crate::Error>>
    + use<'_, 'app, 'local, 'd, I> {
        self.guard.state().transaction()
    }
}

impl<'query, 'app: 'query, 'local: 'app, 'd: 'local, I: catalogs::Catalog>
    api::IntoQuery<'query, 'local, 'd, I> for &'query mut Connection<'app, 'local, 'd, I>
{
    fn into_query(self) -> exec::Query<'query, 'local, 'd, I> {
        self.query()
    }
}

/// Installed database application owned by one executor generation.
pub struct Installed<'local, 'd: 'local, I: catalogs::Catalog> {
    phase: ptr::NonNull<Phase<'local, 'd, I>>,
    ownership: marker::PhantomData<(Phase<'local, 'd, I>, marker::PhantomPinned)>,
}

impl<'local, 'd: 'local, I: catalogs::Catalog> client::Provider<'d> for Installed<'local, 'd, I> {
    type Client<'app>
        = Result<Connection<'app, 'local, 'd, I>, crate::Error>
    where
        Self: 'app,
        'd: 'app;

    fn provide<'app>(context: client::Context<'_, 'app, 'd, Self>) -> Self::Client<'app>
    where
        Self: 'app,
        'd: 'app,
    {
        Lease::try_new(context).map(Connection::new)
    }
}

const _: () = Connection::<catalogs::Empty>::LAYOUT;

const _: () = {
    assert!(mem::size_of::<Installed<'_, '_, catalogs::Empty>>() == mem::size_of::<usize>());
    assert!(mem::align_of::<Installed<'_, '_, catalogs::Empty>>() == mem::align_of::<usize>());
};