search-query-parser 0.1.3

parse complex search query into layered search conditions, so it will be easy to construct Elasticsearch query DSL or something else.
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

# search-query-parser

[![crates.io](https://img.shields.io/crates/v/search-query-parser.svg)](https://crates.io/crates/search-query-parser)
[![docs.rs](https://docs.rs/search-query-parser/badge.svg)](https://docs.rs/search-query-parser)
[![build](https://github.com/dimmy82/search-query-parser/actions/workflows/build_and_test.yml/badge.svg)](https://github.com/dimmy82/search-query-parser/actions)

## what is this library for

search-query-parser is made to parse complex search query into layered search conditions, so it will be easy to construct Elasticsearch query DSL or something else.

the complex search query like this: ↓↓↓

`(word１ and -word２) or (("phrase word １" or -"phrase word ２") and -(" a long phrase word " or word３))`

will be parsed into layered search conditions like this: ↓↓↓

```Rust
Condition::Operator(
    Operator::Or,
    vec![
        Condition::Operator(
            Operator::And,
            vec![
                Condition::Keyword("word１".into()),
                Condition::Not(Box::new(Condition::Keyword("word２".into()))),
            ]
        ),
        Condition::Operator(
            Operator::And,
            vec![
                Condition::Operator(
                    Operator::Or,
                    vec![
                        Condition::PhraseKeyword("phrase word １".into()),
                        Condition::Not(Box::new(Condition::PhraseKeyword(
                            "phrase word ２".into()
                        )))
                    ]
                ),
                Condition::Not(Box::new(Condition::Operator(
                    Operator::Or,
                    vec![
                        Condition::PhraseKeyword(" a long phrase word ".into()),
                        Condition::Keyword("word３".into())
                    ]
                )))
            ]
        ),
    ]
)
```

the conditions are constructed by the `enum Condition` and `enum Operator`.

```Rust
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Condition {
    None,
    Keyword(String),
    PhraseKeyword(String),
    Not(Box<Condition>),
    Operator(Operator, Vec<Condition>),
}

#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Operator {
    And,
    Or,
}
```

## usage

```toml
[dependencies]
search-query-parser = "0.1.1"
```

```Rust
use search_query_parser::parse_query_to_condition;

let condition = parse_query_to_condition("any query string you like")?;
```

## parse rules

### 1. space {\u0020} or full width space {\u3000} are identified as `AND` operator

```Rust
assert_eq!(
    parse_query_to_condition("word1 word2").unwrap(),
    parse_query_to_condition("word1 AND word2").unwrap()
);
```

### 2. conditions in brackets have higher priority

```Rust
assert_eq!(
    parse_query_to_condition("word1 OR (word2 AND word3)").unwrap(),
    Condition::Operator(
        Operator::Or,
        vec![
            Condition::Keyword("word1".into()),
            Condition::Operator(
                Operator::And,
                vec![
                    Condition::Keyword("word2".into()),
                    Condition::Keyword("word3".into()),
                ]
            )
        ]
    )
);
```

### 3. `AND` operator has higher priority than `OR` operator

```Rust
assert_eq!(
    parse_query_to_condition("word1 OR word2 AND word3").unwrap(),
    parse_query_to_condition("word1 OR (word2 AND word3)").unwrap()
);
```