gqlite 1.8.0 → 1.8.2

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 =>
@@ -506,7 +507,18 @@ impl std::fmt::Display for Value
       Value::Float(fl) => write!(f, "{}", fl),
       Value::String(s) => write!(f, "{}", s),
       Value::TimeStamp(t) => write!(f, "{}", t),
-      Value::Array(v) => write!(f, "[{}]", v.iter().map(|x| x.to_string()).join(", ")),
+      Value::Array(v) =>
+      {
+        let formatted = v
+          .iter()
+          .map(|x| match x
+          {
+            Value::String(s) => format!("\"{}\"", s),
+            _ => x.to_string(),
+          })
+          .join(", ");
+        write!(f, "[{}]", formatted)
+      }
       Value::Tensor(v) => write!(f, "[{}]", v.iter().map(|x| x.to_string()).join(", ")),
       Value::Map(o) => write!(f, "{}", o),
       Value::Node(n) => write!(f, "{}", n),

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gqlite
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.2
 platform: ruby
 authors:
 - Cyrille Berger
@@ -129,8 +129,11 @@ files:
 - ext/gqlitedb/src/interpreter/evaluators.rs
 - ext/gqlitedb/src/interpreter/instructions.rs
 - ext/gqlitedb/src/interpreter/mod.rs
+- ext/gqlitedb/src/interpreter/path.rs
+- ext/gqlitedb/src/interpreter/path/bfs.rs
+- ext/gqlitedb/src/interpreter/path/dfs.rs
+- ext/gqlitedb/src/interpreter/path/group.rs
 - ext/gqlitedb/src/lib.rs
-- ext/gqlitedb/src/parser/gql.pest
 - ext/gqlitedb/src/planner.rs
 - ext/gqlitedb/src/prelude.rs
 - ext/gqlitedb/src/query_result.rs
@@ -233,6 +236,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

data/ext/gqlitedb/src/parser/gql.pest

@@ -1,198 +0,0 @@
-WHITESPACE     = _{ " " | "\t" | "\n" | "\r\n" }
-COMMENT        = _{ ("//" ~ (!"\n" ~ ANY)*) | ("/*" ~ (!"*/" ~ ANY)* ~ "*/") }
-ident          = @{ ASCII_ALPHA ~ (ASCII_ALPHANUMERIC | "_")* }
-parameter_name = @{ (ASCII_ALPHANUMERIC | "_")* }
-char_single    =  {
-    !("'" | "\\") ~ ANY
-  | "\\" ~ ("\"" | "\\" | "/" | "b" | "f" | "n" | "r" | "t" | "'")
-  | "\\" ~ ("u" ~ ASCII_HEX_DIGIT{4})
-}
-char_double    =  {
-    !("\"" | "\\") ~ ANY
-  | "\\" ~ ("\"" | "\\" | "/" | "b" | "f" | "n" | "r" | "t" | "'")
-  | "\\" ~ ("u" ~ ASCII_HEX_DIGIT{4})
-}
-char_tick      =  {
-    !("`" | "\\") ~ ANY
-  | "\\" ~ ("\"" | "\\" | "/" | "b" | "f" | "n" | "r" | "t" | "'")
-  | "\\" ~ ("u" ~ ASCII_HEX_DIGIT{4})
-}
-nothing_ident  = @{ "###"+ }
-
-// Query
-queries = _{ SOI ~ query ~ (";" ~ query)* ~ ";"? ~ EOI }
-
-query = { statement* }
-
-nothing = { nothing_ident? }
-
-// fragments
-
-labels       = { ":" ~ label_expression }
-pattern      = { ident? ~ labels? ~ (map | parameter)? }
-node_pattern = { "(" ~ pattern ~ ")" }
-
-directed_edge_pattern   = { (")-[" ~ pattern ~ "]->(") | (nothing ~ ")-->(") }
-reversed_edge_pattern   = { (")<-[" ~ pattern ~ "]-(") | (nothing ~ ")<--(") }
-undirected_edge_pattern = { (")-[" ~ pattern ~ "]-(") | (")<-[" ~ pattern ~ "]->(") | (nothing ~ ")--(") }
-edge_pattern            = { "(" ~ pattern ~ ((directed_edge_pattern | reversed_edge_pattern | undirected_edge_pattern) ~ pattern)+ ~ ")" }
-
-path_pattern = { ident ~ "=" ~ "(" ~ pattern ~ (directed_edge_pattern | reversed_edge_pattern | undirected_edge_pattern) ~ pattern ~ ")" }
-
-node_or_edge_pattern         = _{ edge_pattern | node_pattern }
-node_or_edge_or_path_pattern = _{ edge_pattern | node_pattern | path_pattern }
-
-// Modifiers
-
-order_by_kw = @{ "ORDER" ~ WHITESPACE+ ~ "BY" ~ !ASCII_ALPHA }
-limit_kw    = @{ "LIMIT" ~ !ASCII_ALPHA }
-skip_kw     = @{ "SKIP" ~ !ASCII_ALPHA }
-
-limit                    = { limit_kw ~ expression }
-order_by                 = { order_by_kw ~ (order_by_desc_expression | order_by_asc_expression) ~ ("," ~ (order_by_desc_expression | order_by_asc_expression))* }
-order_by_asc_expression  = { expression ~ ("ASCENDING" | "ASC")? }
-order_by_desc_expression = { expression ~ ("DESCENDING" | "DESC") }
-skip                     = { skip_kw ~ expression }
-modifiers                = {
-    (limit ~ ((order_by ~ skip?) | (skip? ~ order_by?)))
-  | (order_by ~ ((limit ~ skip?) | (skip? ~ limit?)))
-  | (skip ~ ((order_by ~ limit?) | (limit? ~ order_by?)))
-}
-
-where_modifier = { "WHERE" ~ expression }
-
-// Statements
-statement = {
-    create_graph_if_not_exists_statement
-  | create_graph_statement
-  | drop_graph_if_exists_statement
-  | drop_graph_statement
-  | use_graph_statement
-  | create_statement
-  | optional_match_statement
-  | match_statement
-  | return_statement
-  | call_statement
-  | with_statement
-  | unwind_statement
-  | delete_statement
-  | detach_delete_statement
-  | set_statement
-  | remove_statement
-}
-
-star = { "*" }
-
-create_graph_statement   = { "CREATE" ~ "GRAPH" ~ ident }
-create_graph_if_not_exists_statement   = { "CREATE" ~ "GRAPH" ~ "IF" ~ "NOT" ~ "EXISTS" ~ ident }
-drop_graph_statement     = { "DROP" ~ "GRAPH" ~ ident }
-drop_graph_if_exists_statement     = { "DROP" ~ "GRAPH" ~ "IF" ~ "EXISTS" ~ ident }
-use_graph_statement      = { "USE" ~ ident }
-
-create_statement         = { "CREATE" ~ node_or_edge_pattern ~ ("," ~ node_or_edge_pattern)* }
-match_statement          = { "MATCH" ~ node_or_edge_or_path_pattern ~ ("," ~ node_or_edge_or_path_pattern)* ~ where_modifier? }
-optional_match_statement = { "OPTIONAL" ~ match_statement }
-return_statement         = { "RETURN" ~ (star | named_expression) ~ ("," ~ named_expression)* ~ modifiers? }
-call_statement           = { "CALL" ~ function_name ~ "()" }
-with_statement           = { "WITH" ~ (star | named_expression) ~ ("," ~ named_expression)* ~ where_modifier? ~ modifiers? }
-unwind_statement         = { "UNWIND" ~ named_expression }
-delete_statement         = { "DELETE" ~ expression ~ ("," ~ expression)* }
-detach_delete_statement  = { "DETACH" ~ "DELETE" ~ expression ~ ("," ~ expression)* }
-set_statement            = { "SET" ~ set_expression ~ ("," ~ set_expression)* }
-remove_statement         = { "REMOVE" ~ remove_expression ~ ("," ~ remove_expression)* }
-
-// literals
-int            = @{ ("+" | "-")? ~ ('0'..'9')+ }
-octa_int       = @{ ("+" | "-")? ~ "0o" ~ ('0'..'9' | 'a' .. 'f' | 'A' .. 'F')+ }
-hexa_int       = @{ ("+" | "-")? ~ "0x" ~ ('0'..'9' | 'a' .. 'f' | 'A' .. 'F')+ }
-null_lit       =  { "null" }
-true_lit       =  { "true" }
-false_lit      =  { "false" }
-num            = @{ (int? ~ "." ~ ASCII_DIGIT+ ~ (^"e" ~ int)?) | (int ~ ^"e" ~ int) }
-string_literal = ${ ("'" ~ inner_single ~ "'") | ("\"" ~ inner_double ~ "\"") | ("`" ~ inner_tick ~ "`") }
-inner_tick     = @{ char_tick* }
-inner_double   = @{ char_double* }
-inner_single   = @{ char_single* }
-function_name  =  { ident ~ ("." ~ ident)* }
-
-// Expression
-
-set_expression       = _{ set_eq_expression | set_add_expression | set_label_expression }
-set_eq_expression    =  { set_eq_member_access ~ "=" ~ expression }
-set_add_expression   =  { set_eq_member_access ~ "+=" ~ expression }
-remove_expression    = _{ remove_member_access | set_label_expression }
-set_label_expression =  { ident ~ (":" ~ ident)+ }
-set_eq_member_access =  { (("(" ~ ident ~ ")") | ident) ~ ("." ~ ident)* }
-remove_member_access =  { (("(" ~ ident ~ ")") | ident) ~ ("." ~ ident)+ }
-
-expression = { prefix* ~ expression_term ~ postfix* ~ (infix ~ prefix? ~ expression_term ~ postfix*)* }
-
-infix   = _{ addition | subtraction | multiplication | division | modulo | exponent | or | and | xor | equal | different | in_ | not_in | superior_equal | inferior_equal | superior | inferior }
-postfix = _{ is_null | is_not_null | member_access | range_access | range_access_to | index_access }
-prefix  = _{ negation | not }
-
-addition       = { "+" }
-subtraction    = { "-" }
-multiplication = { "*" }
-division       = { "/" }
-modulo         = { "%" }
-exponent       = { "^" }
-
-xor_kw         = @{ "XOR" ~ !ASCII_ALPHA }
-xor            =  { xor_kw }
-or_kw          = @{ "OR" ~ !ASCII_ALPHA }
-or             =  { or_kw }
-and_kw         = @{ "AND" ~ !ASCII_ALPHA }
-and            =  { and_kw }
-equal          =  { "=" }
-different      =  { "<>" }
-inferior_kw    = @{ "<" ~ (!">" | !"=") }
-inferior       =  { inferior_kw }
-superior_kw    = @{ ">" ~ !"=" }
-superior       =  { superior_kw }
-inferior_equal =  { "<=" }
-superior_equal =  { ">=" }
-not_in         =  { "NOT" ~ "IN" }
-in_            =  { "IN" }
-
-negation =  { "-" ~ !int }
-not_kw   = @{ "NOT" ~ !ASCII_ALPHA }
-not      =  { not_kw }
-
-is_null         = { "IS" ~ "NULL" }
-is_not_null     = { "IS" ~ "NOT" ~ "NULL" }
-member_access   = { ("." ~ (ident | string_literal))+ }
-index_access    = { "[" ~ expression ~ "]" }
-range_access    = { "[" ~ expression ~ ".." ~ expression? ~ "]" }
-range_access_to = { "[" ~ ".." ~ expression ~ "]" }
-
-label_check_expression = { ident ~ (":" ~ ident)+ }
-
-parenthesised_expression = { "(" ~ expression ~ ")" }
-named_expression         = { (expression ~ "AS" ~ ident) | expression }
-function_call            = { function_name ~ "(" ~ (expression ~ ("," ~ expression)*)? ~ ")" }
-function_star            = { function_name ~ "(" ~ "*" ~ ")" }
-expression_term          = { null_lit | true_lit | false_lit | num | hexa_int | octa_int | int | string_literal | map | array | label_check_expression | parameter | parenthesised_expression | function_call | function_star | ident }
-
-parameter = { "$" ~ parameter_name }
-
-pair = { (ident | string_literal) ~ ":" ~ expression }
-
-array = {
-    "[" ~ "]"
-  | "[" ~ expression ~ ("," ~ expression)* ~ "]"
-}
-
-map = {
-    "{" ~ "}"
-  | "{" ~ pair ~ ("," ~ pair)* ~ "}"
-}
-
-// label_expression
-
-label_expression = _{ label_inclusion }
-
-label_inclusion   = { label_alternative ~ (":" ~ label_expression)* }
-label_alternative = { label_atom ~ ("|" ~ label_expression)* }
-label_atom        = { label_group | ":"? ~ ident }
-label_group       = { "(" ~ label_expression ~ ")" }