libsql 0.5.0

libSQL library: the main gateway for interacting with the database
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

use crate::hrana::HranaRows;
use crate::Row;
use bytes::Bytes;
use futures::Stream;

pub struct Rows {
    pub(super) inner: Box<dyn RowsInner>,
}

impl Rows {
    pub async fn next(&mut self) -> crate::Result<Option<Row>> {
        self.inner.next().await
    }

    pub fn column_count(&self) -> i32 {
        self.inner.column_count()
    }

    pub fn column_name(&self, idx: i32) -> Option<&str> {
        self.inner.column_name(idx)
    }

    /// Converts current [crate::Rows] into asynchronous stream, fetching rows
    /// one by one. This stream can be further used with [futures::StreamExt]
    /// operators.
    pub fn into_stream(mut self) -> impl Stream<Item = crate::Result<Row>> + Unpin {
        Box::pin(async_stream::try_stream! {
            if let Some(row) = self.next().await? {
                yield row
            }
        })
    }
}

#[async_trait::async_trait(?Send)]
pub(super) trait RowsInner {
    async fn next(&mut self) -> crate::Result<Option<Row>>;

    fn column_count(&self) -> i32;

    fn column_name(&self, idx: i32) -> Option<&str>;
}

#[async_trait::async_trait(?Send)]
impl<S> RowsInner for HranaRows<S>
where
    S: Stream<Item = std::io::Result<Bytes>> + Unpin,
{
    async fn next(&mut self) -> crate::Result<Option<Row>> {
        self.next().await
    }

    fn column_count(&self) -> i32 {
        self.column_count()
    }

    fn column_name(&self, idx: i32) -> Option<&str> {
        self.column_name(idx)
    }
}