restq 0.9.1

Compacting SQL query into a URL suitable for rest api calls
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

use serde::{Deserialize, Serialize};
use sqlparser::ast as sql;
use std::fmt;

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
pub enum Operator {
    Plus,
    Minus,
    Multiply,
    Divide,
    //TODO: rename to Modulo
    Modulus,
    Eq,     // = ,  eq
    Neq,    // != , neq
    Lt,     // <,  lt
    Lte,    // <=, lte
    Gt,     // >, gt
    Gte,    // >=, gte
    And,    // AND
    Or,     // OR
    Like,   // LIKE, like
    In,     // (expr) IN, in
    NotIn,  // (expr) NOT IN, not_in
    Is,     // (expr) IS, is
    IsNot,  // (expr) IS NOT, is_not
    Ilike,  // ILIKE case insensitive like, postgresql specific
    Starts, // Starts with, which will become ILIKE 'value%'
}

impl Operator {
    pub(crate) fn needs_separator(&self) -> bool {
        match self {
            Operator::And
            | Operator::Or
            | Operator::Plus
            | Operator::Minus
            | Operator::Multiply
            | Operator::Divide
            | Operator::Modulus => false,

            Operator::Eq
            | Operator::Neq
            | Operator::Lt
            | Operator::Lte
            | Operator::Gt
            | Operator::Gte
            | Operator::Like
            | Operator::In
            | Operator::NotIn
            | Operator::Is
            | Operator::IsNot
            | Operator::Ilike
            | Operator::Starts => true,
        }
    }
}

/// convert restq to sql_ast operator
impl Into<sql::BinaryOperator> for &Operator {
    fn into(self) -> sql::BinaryOperator {
        match self {
            Operator::Eq => sql::BinaryOperator::Eq,
            Operator::Neq => sql::BinaryOperator::NotEq,
            Operator::Lt => sql::BinaryOperator::Lt,
            Operator::Lte => sql::BinaryOperator::LtEq,
            Operator::Gt => sql::BinaryOperator::Gt,
            Operator::Gte => sql::BinaryOperator::GtEq,
            Operator::And => sql::BinaryOperator::And,
            Operator::Or => sql::BinaryOperator::Or,
            Operator::Like => sql::BinaryOperator::PGLikeMatch,
            Operator::Ilike => sql::BinaryOperator::PGILikeMatch,
            Operator::Plus => sql::BinaryOperator::Plus,
            Operator::Minus => sql::BinaryOperator::Minus,
            Operator::Multiply => sql::BinaryOperator::Multiply,
            Operator::Divide => sql::BinaryOperator::Divide,
            Operator::Modulus => sql::BinaryOperator::Modulo,
            _ => panic!("unsupported conversion"),
        }
    }
}

impl fmt::Display for Operator {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Operator::Plus => write!(f, "+"),
            Operator::Minus => write!(f, "-"),
            Operator::Multiply => write!(f, "*"),
            Operator::Divide => write!(f, "/"),
            Operator::Modulus => write!(f, "%"),
            Operator::Eq => write!(f, "eq"),
            Operator::Neq => write!(f, "neq"),
            Operator::Lt => write!(f, "lt"),
            Operator::Lte => write!(f, "lte"),
            Operator::Gt => write!(f, "gt"),
            Operator::Gte => write!(f, "gte"),
            Operator::And => write!(f, "&"),
            Operator::Or => write!(f, "|"),
            Operator::Like => write!(f, "like"),
            Operator::In => write!(f, "in"),
            Operator::NotIn => write!(f, "not_in"),
            Operator::Is => write!(f, "is"),
            Operator::IsNot => write!(f, "is_not"),
            Operator::Ilike => write!(f, "ilike"),
            Operator::Starts => write!(f, "starts"),
        }
    }
}