eight 1.0.0-alpha.2

Modular asynchronous embedded key-value 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

use super::{
    lexer::lex,
    parser::{CallType, Parser},
};
use crate::embedded::{messaging::Response, server::Server, Result};
use std::{collections::HashMap, mem};

pub(crate) struct QueryExecutor {
    source: String,
    env: HashMap<String, String>,
}

impl QueryExecutor {
    pub fn new(source: String, env: HashMap<String, String>) -> Self {
        Self { source, env }
    }

    pub async fn execute(&mut self, server: &Server) -> Result<Vec<Response>> {
        let collection = lex(mem::take(&mut self.source));
        let mut parser = Parser::new(mem::take(&mut self.env));
        let mut results = Vec::new();

        for tokens in collection {
            let command = parser.execute(tokens)?;

            match command {
                CallType::Await(request) => {
                    results.push(server.call(request).await?);
                }
                CallType::Spawn(request) => {
                    server.cast(request).await?;
                }
            }
        }

        Ok(results)
    }
}