datasources-memory 0.1.70

In-memory datasource provider
Documentation
use crate::connection::MemoryConnection;
use crate::statement_renderer::MemoryStatementRenderer;
use async_trait::async_trait;
use datasources::{
    ArrayReader, Command, CommandMiddleware, CommandMiddlewareHost, Native, Parameter,
    Reader, Response, Result, Statement, StatementTextRenderer,
};
use std::sync::Arc;

pub struct MemoryCommand {
    host: CommandMiddlewareHost,
    connection: Arc<MemoryConnection>,
    statements: StatementTextRenderer,
}

impl MemoryCommand {
    pub fn new(connection: Arc<MemoryConnection>) -> Self {
        Self {
            host: CommandMiddlewareHost::new(),
            connection,
            statements: StatementTextRenderer::new(Some(Box::new(MemoryStatementRenderer)), None),
        }
    }
}

#[async_trait]
impl Command for MemoryCommand {
    fn connection(&self) -> Arc<dyn datasources::Connection> {
        Arc::clone(&self.connection) as Arc<dyn datasources::Connection>
    }

    fn add_middleware(&self, middleware: Arc<dyn CommandMiddleware>) {
        self.host.add_middleware(middleware);
    }

    fn schema(&self) -> Option<datasources::Schema> {
        self.host.schema()
    }

    fn set_schema(&self, schema: Option<datasources::Schema>) {
        self.host.set_schema(schema);
    }

    async fn execute_reader_native(
        &self,
        text: &Native,
        parameters: Option<&[Parameter]>,
    ) -> Result<Box<dyn Reader>> {
        self.execute_reader(text.text(), parameters).await
    }

    async fn execute_native(
        &self,
        text: &Native,
        parameters: Option<&[Parameter]>,
    ) -> Result<Response> {
        self.execute(text.text(), parameters).await
    }

    async fn execute_reader(
        &self,
        text: &str,
        parameters: Option<&[Parameter]>,
    ) -> Result<Box<dyn Reader>> {
        let connection = self.connection.clone();
        self.host
            .run(text, parameters, move |query, params| {
                let connection = connection.clone();
                async move {
                    connection.ensure_open()?;
                    connection.state.engine.execute(&query, params.as_deref())?;
                    let rows = connection.state.engine.records();
                    Ok((
                        Box::new(ArrayReader::new(rows.clone())) as Box<dyn Reader>,
                        rows,
                    ))
                }
            })
            .await
    }

    async fn execute(&self, text: &str, parameters: Option<&[Parameter]>) -> Result<Response> {
        if text.trim().is_empty() {
            return Err(datasources::DatasourceError::message("empty command"));
        }
        let connection = self.connection.clone();
        self.host
            .run(text, parameters, move |query, params| {
                let connection = connection.clone();
                async move {
                    connection.ensure_open()?;
                    let response = connection.state.engine.execute(&query, params.as_deref())?;
                    Ok((response, vec![]))
                }
            })
            .await
    }

    async fn execute_reader_statement(
        &self,
        statement: &dyn Statement,
        parameters: Option<&[Parameter]>,
    ) -> Result<Box<dyn Reader>> {
        let text = self.statements.render(statement);
        self.execute_reader(&text, parameters).await
    }

    async fn execute_statement(
        &self,
        statement: &dyn Statement,
        parameters: Option<&[Parameter]>,
    ) -> Result<Response> {
        let text = self.statements.render(statement);
        self.execute(&text, parameters).await
    }
}