sonic-server 1.5.0

Fast, lightweight and schema-less search backend.
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

// Sonic
//
// Fast, lightweight and schema-less search backend
// Copyright: 2019, Valerian Saliou <valerian@valeriansaliou.name>
// License: Mozilla Public License v2.0 (MPL v2.0)

use crate::executor::count::ExecutorCount;
use crate::executor::flushb::ExecutorFlushB;
use crate::executor::flushc::ExecutorFlushC;
use crate::executor::flusho::ExecutorFlushO;
use crate::executor::list::ExecutorList;
use crate::executor::pop::ExecutorPop;
use crate::executor::push::ExecutorPush;
use crate::executor::search::ExecutorSearch;
use crate::executor::suggest::ExecutorSuggest;
use crate::query::actions::Query;

pub struct StoreOperationDispatch;

impl StoreOperationDispatch {
    pub fn dispatch(query: Query) -> Result<Option<String>, ()> {
        // Dispatch de-constructed query to its target executor
        match query {
            Query::Search(store, query_id, lexer, limit, offset) => {
                ExecutorSearch::execute(store, query_id, lexer, limit, offset)
                    .map(|results| results.map(|results| results.join(" ")))
            }
            Query::Suggest(store, query_id, lexer, limit) => {
                ExecutorSuggest::execute(store, query_id, lexer, limit)
                    .map(|results| results.map(|results| results.join(" ")))
            }
            Query::List(store, query_id, limit, offset) => {
                ExecutorList::execute(store, query_id, limit, offset)
                    .map(|results| results.join(" "))
                    .map(Some)
            }
            Query::Push(store, lexer) => ExecutorPush::execute(store, lexer).map(|_| None),
            Query::Pop(store, lexer) => {
                ExecutorPop::execute(store, lexer).map(|count| Some(count.to_string()))
            }
            Query::Count(store) => {
                ExecutorCount::execute(store).map(|count| Some(count.to_string()))
            }
            Query::FlushC(store) => {
                ExecutorFlushC::execute(store).map(|count| Some(count.to_string()))
            }
            Query::FlushB(store) => {
                ExecutorFlushB::execute(store).map(|count| Some(count.to_string()))
            }
            Query::FlushO(store) => {
                ExecutorFlushO::execute(store).map(|count| Some(count.to_string()))
            }
        }
    }
}