gqb 0.2.3

GQL Query Builder API.
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

use crate::prelude::*;

pub mod expression_builder;

/// Binary operator
#[derive(Debug)]
pub enum BinOp
{
  And,
  Or,
  Equal,
  Different,
  Superior,
  SuperiorEqual,
  Inferior,
  InferiorEqual,
  Addition,
  Substraction,
  Multiplication,
  Division,
}

impl BinOp
{
  fn into_oc_query(self) -> String
  {
    match self
    {
      BinOp::And => "AND",
      BinOp::Or => "OR",
      BinOp::Equal => "=",
      BinOp::Different => "!=",
      BinOp::Superior => ">",
      BinOp::SuperiorEqual => ">=",
      BinOp::Inferior => "<",
      BinOp::InferiorEqual => "<=",
      BinOp::Addition => "+",
      BinOp::Substraction => "-",
      BinOp::Multiplication => "*",
      BinOp::Division => "/",
    }
    .to_string()
  }
}

/// Expression used in queries.
#[derive(Debug)]
pub enum Expression
{
  FunctionCall
  {
    name: String,
    arguments: Vec<Expression>,
  },
  Variable(Variable),
  Literal(Box<graphcore::Value>),
  Get {
    expression: Box<Expression>,
    path: Vec<String>,
  },
  BinaryOp
  {
    operator: BinOp,
    lhs: Box<Expression>,
    rhs: Box<Expression>,
  },
}

impl Expression
{
  pub(crate) fn into_oc_query(self, bindings: &mut graphcore::ValueMap) -> String
  {
    match self
    {
      Expression::BinaryOp { operator, lhs, rhs } => format!(
        "({}) {} ({})",
        lhs.into_oc_query(bindings),
        operator.into_oc_query(),
        rhs.into_oc_query(bindings)
      ),
      Expression::FunctionCall { name, arguments } => format!(
        "{}({})",
        name,
        arguments
          .into_iter()
          .map(|a| a.into_oc_query(bindings))
          .collect::<Vec<_>>()
          .join(",")
      ),
      Expression::Literal(literal) =>
      {
        let properties_binding = format!("$l{}", bindings.len());
        bindings.insert(properties_binding.clone(), *literal);
        properties_binding
      }
      Expression::Variable(var) => format!("{}", var),
      Expression::Get { expression, path } => format!("{}.{}", expression.into_oc_query(bindings), path.join("."))
    }
  }
}

impl From<Variable> for Expression
{
  fn from(value: Variable) -> Self
  {
    Self::Variable(value)
  }
}

impl<T> From<T> for Expression
where
  graphcore::Value: From<T>,
{
  fn from(value: T) -> Self
  {
    Self::Literal(Box::new(value.into()))
  }
}