cartel-sqlite 0.31.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

use crate::{options, runtime, sys};
use std::{mem, time};

#[derive(Debug)]
pub enum Error {
    Catalog(crate::Error),
    ParameterItemsZero,
    ParameterItems {
        actual: usize,
    },
    ParameterBytesZero,
    ScanRowsZero,
    RowBytesZero,
    RowBytes {
        actual: usize,
    },
    CollectRows {
        actual: usize,
        maximum: usize,
    },
    CollectBytes {
        actual: usize,
        required: usize,
    },
    StatementBytes {
        actual: usize,
        maximum: usize,
    },
    MainCacheBytes {
        actual: usize,
    },
    MainCacheInteger {
        actual: usize,
    },
    TemporaryCacheBytes {
        actual: usize,
    },
    TemporaryCacheInteger {
        actual: usize,
    },
    Contention {
        operation: Operation,
        interval: time::Duration,
        window: time::Duration,
    },
    Savepoints {
        actual: usize,
        maximum: usize,
    },
    Runtime(runtime::Error),
}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Operation {
    Open,
    Call,
}

pub struct Target<'sql> {
    location: Location,
    options: options::OpenOptions,
    commands: sys::Commands<'sql>,
}

const _: () = {
    assert!(!mem::needs_drop::<Error>());
    assert!(mem::size_of::<Error>() <= 5 * mem::size_of::<usize>());
};

pub(crate) enum Location {
    File(sys::Filename),
    Memory,
}

#[derive(Clone, Copy)]
pub(crate) enum Kind {
    File,
    Memory,
}

impl Location {
    pub(crate) const fn kind(&self) -> Kind {
        match self {
            Self::File(_) => Kind::File,
            Self::Memory => Kind::Memory,
        }
    }
}

impl<'sql> Target<'sql> {
    pub(crate) fn new(
        _: runtime::Runtime,
        location: Location,
        options: options::OpenOptions,
    ) -> Self {
        Self {
            location,
            options,
            commands: sys::Commands::EMPTY,
        }
    }

    /// Runs parameterless, columnless commands before catalog preparation.
    /// Each runs in autocommit mode; later failure preserves earlier changes.
    /// Attaching validates only SQL text and does not open the database.
    pub fn commands(mut self, sql: &'sql [&'sql str]) -> Result<Self, crate::Error> {
        self.commands = sys::Commands::try_new(sql)?;
        Ok(self)
    }

    pub(crate) const fn sql_bytes(&self) -> usize {
        self.commands.max_bytes()
    }

    pub(crate) fn into_parts(self) -> (Location, options::OpenOptions, sys::Commands<'sql>) {
        (self.location, self.options, self.commands)
    }
}