gqlite 1.7.0 → 1.8.1

data/ext/gqlitedb/src/tests/templates/programs.rs

@@ -73,6 +73,7 @@ pub(crate) fn create_named_node() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(2, 0),
     },
@@ -138,6 +139,7 @@ pub(crate) fn create_named_node_double_return() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(3, 0),
     },
@@ -166,6 +168,7 @@ pub(crate) fn double_with_return() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(2, 0),
     },
@@ -187,6 +190,7 @@ pub(crate) fn double_with_return() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(4, 0),
     },
@@ -204,6 +208,7 @@ pub(crate) fn double_with_return() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(2, 0),
     },
@@ -239,6 +244,7 @@ pub(crate) fn unwind() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(1, 0),
     },
@@ -294,6 +300,7 @@ pub(crate) fn match_loop() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(1, 0),
     },
@@ -333,6 +340,7 @@ pub(crate) fn optional_match() -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(1, 0),
     },
@@ -375,6 +383,7 @@ pub(crate) fn match_count(function_manager: &functions::Manager) -> Program
               aggregator: function_manager
                 .get_aggregator::<error::CompileTimeError>("count")
                 .unwrap(),
+              distinct: false,
             },
           )],
         },
@@ -384,6 +393,7 @@ pub(crate) fn match_count(function_manager: &functions::Manager) -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(2, 1),
     },
@@ -445,6 +455,7 @@ pub(crate) fn aggregation(function_manager: &functions::Manager) -> Program
                 aggregator: function_manager
                   .get_aggregator::<error::CompileTimeError>("count")
                   .unwrap(),
+                distinct: false,
               },
             )],
           },
@@ -455,6 +466,7 @@ pub(crate) fn aggregation(function_manager: &functions::Manager) -> Program
         limit: None,
         skip: None,
         order_by: vec![],
+        distinct: false,
       },
       variables_sizes: create_variable_size(3, 1),
     },

data/ext/gqlparser/src/oc/ast.rs

@@ -378,11 +378,22 @@ pub struct OrderBy
 #[derive(Default, Debug)]
 pub struct Modifiers
 {
+  pub distinct: bool,
   pub skip: Option<Expression>,
   pub limit: Option<Expression>,
   pub order_by: Option<OrderBy>,
 }
 
+impl Modifiers
+{
+  /// Set the distinct field
+  pub(crate) fn set_distinct(mut self, distinct: bool) -> Self
+  {
+    self.distinct = distinct;
+    self
+  }
+}
+
 // Expressions
 
 #[derive(Debug, Clone, PartialEq)]
@@ -411,6 +422,10 @@ pub enum Expression
   RelationalIn(Box<RelationalIn>),
   RelationalNotIn(Box<RelationalNotIn>),
 
+  Contains(Box<Contains>),
+  EndsWith(Box<EndsWith>),
+  StartsWith(Box<StartsWith>),
+
   Addition(Box<Addition>),
   Subtraction(Box<Subtraction>),
   Multiplication(Box<Multiplication>),
@@ -601,6 +616,7 @@ pub struct FunctionCall
 {
   pub name: String,
   pub arguments: Vec<Expression>,
+  pub distinct: bool,
 }
 
 create_from_expr! {FunctionCall}
@@ -630,6 +646,10 @@ create_binary_op! {RelationalSuperiorEqual}
 create_binary_op! {RelationalIn}
 create_binary_op! {RelationalNotIn}
 
+create_binary_op! {Contains}
+create_binary_op! {EndsWith}
+create_binary_op! {StartsWith}
+
 create_binary_op! {Addition}
 create_binary_op! {Subtraction}
 create_binary_op! {Multiplication}

data/ext/gqlparser/src/oc/lexer.rs

@@ -22,17 +22,23 @@ pub(crate) enum Token
   By,
   #[token("call", ignore(case))]
   Call,
+  #[token("contains", ignore(case))]
+  Contains,
+  #[token("create", ignore(case))]
+  Create,
   #[token("desc", ignore(case))]
   #[token("descending", ignore(case))]
   Desc,
-  #[token("create", ignore(case))]
-  Create,
   #[token("delete", ignore(case))]
   Delete,
   #[token("detach", ignore(case))]
   Detach,
+  #[token("distinct", ignore(case))]
+  Distinct,
   #[token("drop", ignore(case))]
   Drop,
+  #[token("ends", ignore(case))]
+  Ends,
   #[token("exists", ignore(case))]
   Exists,
   #[token("for", ignore(case))]
@@ -65,6 +71,8 @@ pub(crate) enum Token
   Search,
   #[token("set", ignore(case))]
   Set,
+  #[token("starts", ignore(case))]
+  Starts,
   #[token("not", ignore(case))]
   Not,
   #[token("null", ignore(case))]
@@ -188,6 +196,7 @@ impl Token
         | Token::By
         | Token::Call
         | Token::Desc
+        | Token::Distinct
         | Token::Create
         | Token::Delete
         | Token::Detach

data/ext/gqlparser/src/oc/parser/tests.rs

@@ -101,6 +101,17 @@ where
   assert_eq!(unwrap_nom(input.clone(), parser.parse(input)), exp);
 }
 
+fn parse_string<P>(s: &str, mut parser: P, exp: impl Into<String>)
+where
+  for<'a> P: nom::Parser<Input<'a>, Output = String, Error = Error>,
+{
+  let exp = exp.into();
+  let ctx = Context::new(s);
+  let tokens = lexer::tokenize(s).expect("tokenization failed");
+  let input = Input(&tokens, &ctx);
+  assert_eq!(unwrap_nom(input.clone(), parser.parse(input)), exp);
+}
+
 #[test]
 fn test_oc_parse_context_variable_identity()
 {
@@ -131,19 +142,19 @@ fn test_oc_parse_parameter_name()
 #[test]
 fn test_oc_parse_string_literal_double_quote()
 {
-  parse_str(r#""hello world""#, string_literal, "hello world");
+  parse_string(r#""hello world""#, string_literal, "hello world");
 }
 
 #[test]
 fn test_oc_parse_string_literal_single_quote()
 {
-  parse_str("'hello world'", string_literal, "hello world");
-  parse_str("', as#?lßdj '", string_literal, ", as#?lßdj ");
+  parse_string("'hello world'", string_literal, "hello world");
+  parse_string("', as#?lßdj '", string_literal, ", as#?lßdj ");
 }
 #[test]
 fn test_oc_parse_string_literal_backtick()
 {
-  parse_str("`hello`", string_literal, "hello");
+  parse_string("`hello`", string_literal, "hello");
 }
 
 #[test]
@@ -307,6 +318,7 @@ fn test_oc_parse_function_call()
         ast::Expression::Value(ast::Value { value: 1.into() }),
         ast::Expression::Value(ast::Value { value: 2.into() }),
       ],
+      distinct: false,
     },
   );
 }
@@ -320,6 +332,7 @@ fn test_oc_parse_function_call_all()
     ast::FunctionCall {
       name: "func".to_string(),
       arguments: vec![ast::Expression::Value(ast::Value { value: 0.into() })],
+      distinct: false,
     },
   );
 }
@@ -384,6 +397,7 @@ fn test_oc_parse_relational_binary_operator()
           }
           .into(),
         ],
+        distinct: false,
       }
       .into(),
       right: ast::FunctionCall {
@@ -397,6 +411,7 @@ fn test_oc_parse_relational_binary_operator()
           }
           .into(),
         ],
+        distinct: false,
       }
       .into(),
     },
@@ -1261,6 +1276,35 @@ fn test_oc_parse_return_n()
   compare_ast(vec![stmt], vec![exppected_stmt]);
 }
 
+#[test]
+fn test_oc_parse_return_distinct_n()
+{
+  let stmt = parse("RETURN DISTINCT n", return_statement);
+
+  let exppected_stmt = ast::Statement::Return(ast::Return {
+    all: false,
+    expressions: vec![ast::NamedExpression {
+      identifier: ast::VariableIdentifier {
+        name: "n".to_string(),
+        id: 0,
+      },
+      expression: ast::Variable {
+        identifier: ast::VariableIdentifier {
+          name: "n".to_string(),
+          id: 0,
+        },
+      }
+      .into(),
+    }],
+    where_expression: None,
+    modifiers: ast::Modifiers {
+      distinct: true,
+      ..Default::default()
+    },
+  });
+  compare_ast(vec![stmt], vec![exppected_stmt]);
+}
+
 #[test]
 fn test_oc_parse_return_n_m()
 {
@@ -1411,9 +1455,8 @@ fn test_oc_parse_return_n_modifiers()
       }],
       where_expression: None,
       modifiers: ast::Modifiers {
-        order_by: None,
         limit: Some(ast::Expression::Value(ast::Value { value: (-1).into() })),
-        skip: None,
+        ..Default::default()
       },
     }),
   );
@@ -1529,6 +1572,7 @@ fn test_oc_parse_modifiers()
       }),
       limit: Some(ast::Expression::Value(ast::Value { value: 4.into() })),
       skip: Some(ast::Expression::Value(ast::Value { value: 2.into() })),
+      ..Default::default()
     },
   );
   compare_parse_to_ast(
@@ -1569,15 +1613,15 @@ fn test_oc_parse_modifiers()
       }),
       limit: Some(ast::Expression::Value(ast::Value { value: 4.into() })),
       skip: None,
+      ..Default::default()
     },
   );
   compare_parse_to_ast(
     "LIMIT -1",
     modifiers,
     ast::Modifiers {
-      order_by: None,
       limit: Some(ast::Expression::Value(ast::Value { value: (-1).into() })),
-      skip: None,
+      ..Default::default()
     },
   );
 }
@@ -1638,7 +1682,7 @@ fn test_oc_parse_with_modifiers()
           ],
         }),
         limit: Some(ast::Expression::Value(ast::Value { value: 4.into() })),
-        skip: None,
+        ..Default::default()
       },
     },
   );
@@ -2127,6 +2171,72 @@ fn test_oc_parse_match_with_search_basic()
   }
 }
 
+#[test]
+fn test_oc_parse_starts_with()
+{
+  compare_parse_to_ast(
+    "s STARTS WITH 'hello'",
+    expression,
+    ast::StartsWith {
+      left: ast::Variable {
+        identifier: ast::VariableIdentifier {
+          name: "s".to_string(),
+          id: 0,
+        },
+      }
+      .into(),
+      right: ast::Value {
+        value: "hello".into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_ends_with()
+{
+  compare_parse_to_ast(
+    "s ENDS WITH 'world'",
+    expression,
+    ast::EndsWith {
+      left: ast::Variable {
+        identifier: ast::VariableIdentifier {
+          name: "s".to_string(),
+          id: 0,
+        },
+      }
+      .into(),
+      right: ast::Value {
+        value: "world".into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_contains()
+{
+  compare_parse_to_ast(
+    "s CONTAINS 'test'",
+    expression,
+    ast::Contains {
+      left: ast::Variable {
+        identifier: ast::VariableIdentifier {
+          name: "s".to_string(),
+          id: 0,
+        },
+      }
+      .into(),
+      right: ast::Value {
+        value: "test".into(),
+      }
+      .into(),
+    },
+  );
+}
+
 #[test]
 fn test_oc_parse_match_with_search_and_score()
 {
@@ -2282,3 +2392,254 @@ fn test_oc_parse_create_vector_index_if_not_exists()
     },
   );
 }
+
+#[test]
+fn test_oc_parse_not_wraps_full_comparison()
+{
+  compare_parse_to_ast(
+    r#"NOT n.name = "Alice""#,
+    expression,
+    ast::LogicalNegation {
+      value: ast::RelationalEqual {
+        left: ast::MemberAccess {
+          left: ast::Variable {
+            identifier: ast::VariableIdentifier {
+              name: "n".to_string(),
+              id: 0,
+            },
+          }
+          .into(),
+          path: vec!["name".to_string()],
+        }
+        .into(),
+        right: ast::Value {
+          value: "Alice".into(),
+        }
+        .into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_not_and_precedence()
+{
+  compare_parse_to_ast(
+    "NOT a = 1 AND c = 2",
+    expression,
+    ast::LogicalAnd {
+      left: ast::LogicalNegation {
+        value: ast::RelationalEqual {
+          left: ast::Variable {
+            identifier: ast::VariableIdentifier {
+              name: "a".to_string(),
+              id: 0,
+            },
+          }
+          .into(),
+          right: ast::Value { value: 1i64.into() }.into(),
+        }
+        .into(),
+      }
+      .into(),
+      right: ast::RelationalEqual {
+        left: ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "c".to_string(),
+            id: 1,
+          },
+        }
+        .into(),
+        right: ast::Value { value: 2i64.into() }.into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_double_not()
+{
+  compare_parse_to_ast(
+    "NOT NOT a = 1",
+    expression,
+    ast::LogicalNegation {
+      value: ast::LogicalNegation {
+        value: ast::RelationalEqual {
+          left: ast::Variable {
+            identifier: ast::VariableIdentifier {
+              name: "a".to_string(),
+              id: 0,
+            },
+          }
+          .into(),
+          right: ast::Value { value: 1i64.into() }.into(),
+        }
+        .into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_not_true_still_works()
+{
+  compare_parse_to_ast(
+    "NOT true",
+    expression,
+    ast::LogicalNegation {
+      value: ast::Value { value: true.into() }.into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_is_not_null_unaffected()
+{
+  compare_parse_to_ast(
+    "n.age IS NOT NULL",
+    expression,
+    ast::IsNotNull {
+      value: ast::MemberAccess {
+        left: ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "n".to_string(),
+            id: 0,
+          },
+        }
+        .into(),
+        path: vec!["age".to_string()],
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_not_in_still_works()
+{
+  compare_parse_to_ast(
+    "x NOT IN [1, 2]",
+    expression,
+    ast::LogicalNegation {
+      value: ast::RelationalIn {
+        left: ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "x".to_string(),
+            id: 0,
+          },
+        }
+        .into(),
+        right: ast::Array {
+          array: vec![
+            ast::Value { value: 1i64.into() }.into(),
+            ast::Value { value: 2i64.into() }.into(),
+          ],
+        }
+        .into(),
+      }
+      .into(),
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_count_distinct()
+{
+  compare_parse_to_ast(
+    "count(DISTINCT x)",
+    expression,
+    ast::FunctionCall {
+      name: "count".to_string(),
+      arguments: vec![
+        ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "x".to_string(),
+            id: 0,
+          },
+        }
+        .into(),
+      ],
+      distinct: true,
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_count_without_distinct_defaults_false()
+{
+  compare_parse_to_ast(
+    "count(x)",
+    expression,
+    ast::FunctionCall {
+      name: "count".to_string(),
+      arguments: vec![
+        ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "x".to_string(),
+            id: 0,
+          },
+        }
+        .into(),
+      ],
+      distinct: false,
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_sum_distinct()
+{
+  compare_parse_to_ast(
+    "sum(DISTINCT n.age)",
+    expression,
+    ast::FunctionCall {
+      name: "sum".to_string(),
+      arguments: vec![
+        ast::MemberAccess {
+          left: ast::Variable {
+            identifier: ast::VariableIdentifier {
+              name: "n".to_string(),
+              id: 0,
+            },
+          }
+          .into(),
+          path: vec!["age".to_string()],
+        }
+        .into(),
+      ],
+      distinct: true,
+    },
+  );
+}
+
+#[test]
+fn test_oc_parse_function_call_distinct_with_multiple_args()
+{
+  compare_parse_to_ast(
+    "some_func(DISTINCT a, b)",
+    expression,
+    ast::FunctionCall {
+      name: "some_func".to_string(),
+      arguments: vec![
+        ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "a".to_string(),
+            id: 0,
+          },
+        }
+        .into(),
+        ast::Variable {
+          identifier: ast::VariableIdentifier {
+            name: "b".to_string(),
+            id: 1,
+          },
+        }
+        .into(),
+      ],
+      distinct: true,
+    },
+  );
+}