gqlite 1.7.0 → 1.8.1

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

@@ -313,7 +313,7 @@ fn parameter_name(input: Input<'_>) -> OCPResult<Input<'_>, &str>
 }
 // Literals
 
-fn string_literal(input: Input<'_>) -> OCPResult<Input<'_>, &str>
+fn string_literal(input: Input<'_>) -> OCPResult<Input<'_>, String>
 {
   match input.0
   {
@@ -327,7 +327,10 @@ fn string_literal(input: Input<'_>) -> OCPResult<Input<'_>, &str>
     {
       let lit = input.1.extract_text(span);
 
-      Ok((Input(rest, input.1), &lit[1..lit.len() - 1]))
+      Ok((
+        Input(rest, input.1),
+        super::string::unescape_cypher(&lit[1..lit.len() - 1]),
+      ))
     }
     _ => Err(nom::Err::Error(Error::new(
       ErrorKind::ExpectedTokens(vec![Token::String].into()),
@@ -440,11 +443,21 @@ fn function_call(input: Input) -> OCPResult<Input, ast::Expression>
       to_string(ident),
       delimited(
         token(Token::StartParenthesis),
-        separated_list0(token(Token::Comma), expression),
+        pair(
+          map(opt(token(Token::Distinct)), |d| d.is_some()),
+          separated_list0(token(Token::Comma), expression),
+        ),
         token(Token::EndParenthesis),
       ),
     ),
-    |(name, arguments)| ast::FunctionCall { name, arguments }.into(),
+    |(name, (distinct, arguments))| {
+      ast::FunctionCall {
+        name,
+        arguments,
+        distinct,
+      }
+      .into()
+    },
   )
   .parse(input)
 }
@@ -483,9 +496,9 @@ fn primary(input: Input) -> OCPResult<Input, ast::Expression>
       .into()
     }),
     // String
-    map(string_literal, |s: &str| {
+    map(string_literal, |s| {
       ast::Value {
-        value: graphcore::Value::String(s.to_string()),
+        value: graphcore::Value::String(s),
       }
       .into()
     }),
@@ -522,7 +535,7 @@ fn member_access(input: Input) -> OCPResult<Input, ast::Expression>
       primary,
       many0(preceded(
         token(Token::Dot),
-        to_string(alt((ident, string_literal))),
+        alt((to_string(ident), string_literal)),
       )),
     ),
     |(left, path)| {
@@ -617,6 +630,7 @@ fn label_check(input: Input) -> OCPResult<Input, ast::Expression>
               .into()
             }))
             .collect(),
+          distinct: false,
         }
         .into()
       }
@@ -625,6 +639,57 @@ fn label_check(input: Input) -> OCPResult<Input, ast::Expression>
   .parse(input)
 }
 
+#[derive(Clone, Copy)]
+enum StringOp
+{
+  StartsWith,
+  EndsWith,
+  Contains,
+}
+
+fn string_operators(input: Input) -> OCPResult<Input, ast::Expression>
+{
+  map(
+    (
+      label_check,
+      opt(
+        alt((
+          value(
+            StringOp::StartsWith,
+            (token(Token::Starts), token(Token::With)),
+          ),
+          value(StringOp::EndsWith, (token(Token::Ends), token(Token::With))),
+          value(StringOp::Contains, token(Token::Contains)),
+        ))
+        .and(label_check),
+      ),
+    ),
+    |(lhs, op)| match op
+    {
+      None => lhs,
+      Some(op) => match op.0
+      {
+        StringOp::StartsWith => ast::StartsWith {
+          left: lhs,
+          right: op.1,
+        }
+        .into(),
+        StringOp::EndsWith => ast::EndsWith {
+          left: lhs,
+          right: op.1,
+        }
+        .into(),
+        StringOp::Contains => ast::Contains {
+          left: lhs,
+          right: op.1,
+        }
+        .into(),
+      },
+    },
+  )
+  .parse(input)
+}
+
 fn unary(input: Input) -> OCPResult<Input, ast::Expression>
 {
   alt((
@@ -671,9 +736,6 @@ fn unary(input: Input) -> OCPResult<Input, ast::Expression>
         )
       },
     ),
-    map(preceded(token(Token::Not), unary), |e| {
-      ast::LogicalNegation { value: e }.into()
-    }),
     map(preceded(token(Token::Minus), unary), |e| match e
     {
       ast::Expression::Value(ast::Value {
@@ -691,7 +753,7 @@ fn unary(input: Input) -> OCPResult<Input, ast::Expression>
       _ => ast::Negation { value: e }.into(),
     }),
     preceded(token(Token::Plus), unary),
-    label_check,
+    string_operators,
   ))
   .parse(input)
 }
@@ -811,17 +873,42 @@ fn relational(input: Input) -> OCPResult<Input, ast::Expression>
   }
   else
   {
+    // Check for NOT IN pattern
+    if let Ok((after_not, _)) = token(Token::Not).parse(input.clone())
+      && let Ok((after_in, _)) = token(Token::In).parse(after_not)
+    {
+      let (final_input, right) = is_not_null(after_in)?;
+      let in_expr = ast::RelationalIn { left, right }.into();
+      let negated = ast::LogicalNegation { value: in_expr }.into();
+      return Ok((final_input, negated));
+    }
     Ok((input, left))
   }
 }
 
+fn not_expression(input: Input) -> OCPResult<Input, ast::Expression>
+{
+  map(
+    pair(many0(token(Token::Not)), relational),
+    |(nots, expr)| {
+      nots
+        .into_iter()
+        .fold(expr, |e, _| ast::LogicalNegation { value: e }.into())
+    },
+  )
+  .parse(input)
+}
+
 fn logical_and(input: Input) -> OCPResult<Input, ast::Expression>
 {
-  map(separated_list1(token(Token::And), relational), |mut v| {
-    let first = v.remove(0);
-    v.into_iter()
-      .fold(first, |l, r| ast::LogicalAnd { left: l, right: r }.into())
-  })
+  map(
+    separated_list1(token(Token::And), not_expression),
+    |mut v| {
+      let first = v.remove(0);
+      v.into_iter()
+        .fold(first, |l, r| ast::LogicalAnd { left: l, right: r }.into())
+    },
+  )
   .parse(input)
 }
 
@@ -907,7 +994,7 @@ fn labels(input: Input) -> OCPResult<Input, ast::LabelExpression>
 fn map_pair(input: Input) -> OCPResult<Input, (String, ast::Expression)>
 {
   separated_pair(
-    to_string(alt((ident, string_literal))),
+    alt((to_string(ident), string_literal)),
     token(Token::Colon),
     expression,
   )
@@ -1656,15 +1743,16 @@ fn return_statement(input: Input) -> OCPResult<Input, ast::Statement>
   map(
     (
       token(Token::Return),
+      opt(token(Token::Distinct)),
       with_return_expression,
       modifiers,
       opt(preceded(token(Token::Where), expression)),
     ),
-    |(_, (all, expressions), modifiers, where_expression)| {
+    |(_, distinct, (all, expressions), modifiers, where_expression)| {
       ast::Return {
         all,
         expressions,
-        modifiers,
+        modifiers: modifiers.set_distinct(distinct.is_some()),
         where_expression,
       }
       .into()
@@ -1678,15 +1766,16 @@ fn with_statement(input: Input) -> OCPResult<Input, ast::Statement>
   map(
     (
       token(Token::With),
+      opt(token(Token::Distinct)),
       with_return_expression,
       modifiers,
       opt(preceded(token(Token::Where), expression)),
     ),
-    |(_, (all, expressions), modifiers, where_expression)| {
+    |(_, distinct, (all, expressions), modifiers, where_expression)| {
       ast::With {
         all,
         expressions,
-        modifiers,
+        modifiers: modifiers.set_distinct(distinct.is_some()),
         where_expression,
       }
       .into()
@@ -1747,7 +1836,7 @@ fn parse_set_actions(input: Input) -> OCPResult<Input, Vec<ast::OneUpdate>>
           )),
           many0(preceded(
             token(Token::Dot),
-            to_string(alt((ident, string_literal))),
+            alt((to_string(ident), string_literal)),
           )),
           token(Token::Equal),
           expression,
@@ -1772,7 +1861,7 @@ fn parse_set_actions(input: Input) -> OCPResult<Input, Vec<ast::OneUpdate>>
           )),
           many0(preceded(
             token(Token::Dot),
-            to_string(alt((ident, string_literal))),
+            alt((to_string(ident), string_literal)),
           )),
           token(Token::PlusEqual),
           expression,
@@ -1824,7 +1913,7 @@ fn remove_statement(input: Input) -> OCPResult<Input, ast::Statement>
               ident,
               many1(preceded(
                 token(Token::Dot),
-                to_string(alt((ident, string_literal))),
+                alt((to_string(ident), string_literal)),
               )),
             ),
             |(ident, path)| {
@@ -1884,13 +1973,7 @@ fn call_statement(input: Input) -> OCPResult<Input, ast::Statement>
 fn use_statement(input: Input) -> OCPResult<Input, ast::Statement>
 {
   map(
-    (
-      token(Token::Use),
-      alt((
-        map(string_literal, |s| s.to_string()),
-        map(ident, |s| s.to_string()),
-      )),
-    ),
+    (token(Token::Use), alt((string_literal, to_string(ident)))),
     |(_, name)| ast::UseGraph { name }.into(),
   )
   .parse(input)
@@ -1903,10 +1986,7 @@ fn create_graph_statement(input: Input) -> OCPResult<Input, ast::Statement>
       token(Token::Create),
       token(Token::Graph),
       opt((token(Token::If), token(Token::Not), token(Token::Exists))),
-      alt((
-        map(string_literal, |s| s.to_string()),
-        map(ident, |s| s.to_string()),
-      )),
+      alt((string_literal, to_string(ident))),
     ),
     |(_, _, if_not_exists, name)| {
       ast::CreateGraph {
@@ -1926,10 +2006,7 @@ fn drop_graph_statement(input: Input) -> OCPResult<Input, ast::Statement>
       token(Token::Drop),
       token(Token::Graph),
       opt((token(Token::If), token(Token::Exists))),
-      alt((
-        map(string_literal, |s| s.to_string()),
-        map(ident, |s| s.to_string()),
-      )),
+      alt((string_literal, to_string(ident))),
     ),
     |(_, _, if_exists, name)| {
       ast::DropGraph {

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

@@ -0,0 +1,172 @@
+use logos::Logos;
+
+#[derive(Logos, Debug, PartialEq)]
+enum CypherEscapeToken<'a>
+{
+  #[regex(r#"[^\\]+"#, |lex| lex.slice())]
+  Text(&'a str),
+
+  #[token(r"\t")]
+  Tab,
+
+  #[token(r"\b")]
+  Backspace,
+
+  #[token(r"\n")]
+  Newline,
+
+  #[token(r"\r")]
+  CarriageReturn,
+
+  #[token(r"\f")]
+  FormFeed,
+
+  #[token(r"\'")]
+  SingleQuote,
+
+  #[token(r#"\""#)]
+  DoubleQuote,
+
+  #[token(r"\\")]
+  Backslash,
+
+  #[regex(r"\\u[0-9a-fA-F]{4}", |lex| lex.slice())]
+  Unicode16(&'a str),
+
+  #[regex(r"\\U[0-9a-fA-F]{8}", |lex| lex.slice())]
+  Unicode32(&'a str),
+}
+
+pub(crate) fn unescape_cypher(input: &str) -> String
+{
+  let mut output = String::with_capacity(input.len());
+
+  for token in CypherEscapeToken::lexer(input)
+  {
+    match token.expect("invalid Cypher escape")
+    {
+      CypherEscapeToken::Text(s) => output.push_str(s),
+      CypherEscapeToken::Tab => output.push('\t'),
+      CypherEscapeToken::Backspace => output.push('\u{0008}'),
+      CypherEscapeToken::Newline => output.push('\n'),
+      CypherEscapeToken::CarriageReturn => output.push('\r'),
+      CypherEscapeToken::FormFeed => output.push('\u{000C}'),
+      CypherEscapeToken::SingleQuote => output.push('\''),
+      CypherEscapeToken::DoubleQuote => output.push('"'),
+      CypherEscapeToken::Backslash => output.push('\\'),
+
+      CypherEscapeToken::Unicode16(s) =>
+      {
+        let value = u16::from_str_radix(&s[2..], 16).expect("invalid UTF-16 escape");
+
+        let ch = char::from_u32(value as u32).expect("invalid Unicode scalar");
+
+        output.push(ch);
+      }
+
+      CypherEscapeToken::Unicode32(s) =>
+      {
+        let value = u32::from_str_radix(&s[2..], 16).expect("invalid UTF-32 escape");
+
+        output.push(char::from_u32(value).expect("invalid Unicode scalar"));
+      }
+    }
+  }
+
+  output
+}
+
+#[cfg(test)]
+mod tests
+{
+  use super::unescape_cypher;
+
+  #[test]
+  fn plain_text()
+  {
+    assert_eq!(unescape_cypher("hello world"), "hello world");
+  }
+
+  #[test]
+  fn tab()
+  {
+    assert_eq!(unescape_cypher(r"foo\tbar"), "foo\tbar");
+  }
+
+  #[test]
+  fn backspace()
+  {
+    assert_eq!(unescape_cypher(r"foo\bbar"), "foo\u{0008}bar");
+  }
+
+  #[test]
+  fn newline()
+  {
+    assert_eq!(unescape_cypher(r"foo\nbar"), "foo\nbar");
+  }
+
+  #[test]
+  fn carriage_return()
+  {
+    assert_eq!(unescape_cypher(r"foo\rbar"), "foo\rbar");
+  }
+
+  #[test]
+  fn form_feed()
+  {
+    assert_eq!(unescape_cypher(r"foo\fbar"), "foo\u{000C}bar");
+  }
+
+  #[test]
+  fn quotes()
+  {
+    assert_eq!(unescape_cypher(r#"\'hello\""#), "'hello\"");
+  }
+
+  #[test]
+  fn backslash()
+  {
+    assert_eq!(unescape_cypher(r"foo\\bar"), r"foo\bar");
+  }
+
+  #[test]
+  fn unicode_16()
+  {
+    assert_eq!(unescape_cypher(r"\u0041"), "A");
+
+    assert_eq!(unescape_cypher(r"\u03BB"), "λ");
+  }
+
+  #[test]
+  fn unicode_32()
+  {
+    assert_eq!(unescape_cypher(r"\U0001F600"), "😀");
+  }
+
+  #[test]
+  fn mixed_sequences()
+  {
+    assert_eq!(
+      unescape_cypher(r"Hello\nWorld\t\u0021\U0001F600"),
+      "Hello\nWorld\t!😀"
+    );
+  }
+
+  #[test]
+  fn multiple_text_chunks()
+  {
+    assert_eq!(unescape_cypher(r"abc\n123\txyz"), "abc\n123\txyz");
+  }
+
+  #[test]
+  fn empty_string()
+  {
+    assert_eq!(unescape_cypher(""), "");
+  }
+
+  #[test]
+  fn only_escape_sequences()
+  {
+    assert_eq!(unescape_cypher("\n\t\r"), "\n\t\r");
+  }
+}

data/ext/gqlparser/src/oc.rs

@@ -6,6 +6,7 @@ pub mod ast;
 mod error;
 mod lexer;
 mod parser;
+mod string;
 
 pub use error::{Error, ErrorKind};
 

data/ext/graphcore/src/value/value_map.rs

@@ -7,7 +7,7 @@ use std::{
 
 use crate::{Value, prelude::*};
 
-type ValueMapInner = std::collections::HashMap<String, Value>;
+type ValueMapInner = std::collections::BTreeMap<String, Value>;
 
 /// A map of values.
 #[derive(Debug, PartialEq, Default, Clone, Deserialize, Serialize)]
@@ -249,7 +249,7 @@ impl FromIterator<(String, Value)> for ValueMap
   /// all but one of the corresponding values will be dropped.
   fn from_iter<T: IntoIterator<Item = (String, Value)>>(iter: T) -> ValueMap
   {
-    let mut map = ValueMapInner::with_hasher(Default::default());
+    let mut map = ValueMapInner::new();
     map.extend(iter);
     ValueMap(map)
   }

data/ext/graphcore/src/value.rs

@@ -122,6 +122,7 @@ impl Hash for Value
 {
   fn hash<H: std::hash::Hasher>(&self, state: &mut H)
   {
+    std::mem::discriminant(self).hash(state);
     match self
     {
       Value::Null =>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gqlite
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.1
 platform: ruby
 authors:
 - Cyrille Berger
@@ -233,6 +233,7 @@ files:
 - ext/gqlparser/src/oc/lexer.rs
 - ext/gqlparser/src/oc/parser.rs
 - ext/gqlparser/src/oc/parser/tests.rs
+- ext/gqlparser/src/oc/string.rs
 - ext/gqlparser/src/prelude.rs
 - ext/graphcore/Cargo.toml
 - ext/graphcore/README.MD