asqlite 1.3.1

SQLite wrapper using async Rust
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

//! Blocking, single-thread bindings to SQLite.

use crate::{
    convert::{ParamList, SqlRef},
    Result,
};
use std::{cmp::Ordering, ffi::CStr, panic::RefUnwindSafe, sync::Arc, time::Duration};

pub(crate) mod sqlite;

#[derive(Clone, Copy, Debug)]
pub(crate) struct BlobIndex(pub(crate) usize);

#[derive(Clone, Copy, Debug)]
pub(crate) struct StatementIndex(pub(crate) usize);

pub(crate) trait ConnectionFactory: Unpin + Send {
    type Connection: Connection;

    fn open(&self, path: &CStr, flags: i32) -> Result<Self::Connection>;
}

pub(crate) trait Connection: Unpin {
    fn interrupt_handle(&self) -> Arc<dyn InterruptHandle>;

    fn prepare(&mut self, sql: &str) -> Result<Option<(StatementIndex, usize)>>;

    fn bind(&mut self, statement: StatementIndex, param_list: ParamList);

    fn step(&mut self, statement: StatementIndex) -> Result<Option<&mut dyn Row>>;

    fn execute(&mut self, statement: StatementIndex) -> Result<()>;

    fn reset(&mut self, statement: StatementIndex);

    fn finalize(&mut self, statement: StatementIndex);

    fn flush_cache(&mut self) -> Result<()>;

    fn reset_busy_handler(&mut self) -> Result<()>;

    unsafe fn set_busy_handler(&mut self, f: Box<dyn FnMut(u32) -> bool + Send>) -> Result<()>;

    fn set_busy_timeout(&mut self, duration: Duration) -> Result<()>;

    fn create_collation(
        &mut self,
        name: &CStr,
        f: Box<dyn FnMut(&str, &str) -> Ordering>,
    ) -> Result<()>;

    fn open_blob(
        &mut self,
        database: &CStr,
        table: &CStr,
        column: &CStr,
        row: i64,
        flags: i32,
    ) -> Result<BlobIndex>;

    fn reopen_blob(&mut self, index: BlobIndex, row: i64) -> Result<()>;

    fn blob_size(&mut self, index: BlobIndex) -> Result<u64>;

    fn read_blob(&mut self, index: BlobIndex, chunk: &mut [u8], position: u64) -> Result<()>;

    fn write_blob(&mut self, index: BlobIndex, chunk: &[u8], position: u64) -> Result<()>;

    fn close_blob(&mut self, index: BlobIndex);

    fn last_insert_row_id(&mut self) -> i64;

    fn total_changes(&mut self) -> u32;
}

pub(crate) trait Row {
    fn row_len(&self) -> usize;
    fn get(&self, idx: usize) -> Option<Result<SqlRef<'_>>>;
}

pub(crate) trait InterruptHandle: Send + Sync + RefUnwindSafe {
    fn interrupt(&self);
}