gqlite 1.5.0 → 1.7.0

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

@@ -0,0 +1,813 @@
+use graphcore::Value;
+use indexmap::IndexMap;
+use nom::{
+  Parser,
+  branch::alt,
+  bytes::complete::{escaped_transform, is_not, tag, take_while1},
+  character::complete::{char, digit1, multispace0, one_of},
+  combinator::{cut, map, opt, recognize, value},
+  multi::{many0, separated_list0, separated_list1},
+  sequence::{delimited, pair, preceded, terminated},
+};
+
+use crate::{
+  common::*,
+  gqls::{constraint::Constraint, prelude::*},
+};
+
+#[derive(Debug)]
+pub(crate) enum ParseTreeElement
+{
+  Property
+  {
+    label: String,
+    properties: IndexMap<String, Property>,
+    parent: Option<String>,
+  },
+  Node
+  {
+    label: String
+  },
+  Edge
+  {
+    source: String,
+    label: String,
+    destination: String,
+  },
+  ConstrainedType
+  {
+    name: String,
+    def: crate::gqls::ast::ConstrainedTypeDef,
+  },
+}
+
+#[inline]
+fn is_label(chr: char) -> bool
+{
+  chr.is_alphanumeric() || chr == '_'
+}
+
+fn parse_label(input: &str) -> VResult<&str, &str>
+{
+  take_while1(is_label).parse(input)
+}
+
+#[inline]
+fn is_identifier(chr: char) -> bool
+{
+  chr.is_alphanumeric() || chr == '_'
+}
+
+fn parse_identifier(input: &str) -> VResult<&str, &str>
+{
+  take_while1(is_identifier).parse(input)
+}
+
+fn parse_property(input: &str) -> VResult<&str, Property>
+{
+  map(
+    (
+      alt((
+        map(tag("STRING"), |_| {
+          Property::Literal(LiteralBaseType::String.into())
+        }),
+        map(tag("FLOAT"), |_| {
+          Property::Literal(LiteralBaseType::Float.into())
+        }),
+        map(tag("INTEGER"), |_| {
+          Property::Literal(LiteralBaseType::Integer.into())
+        }),
+        map(tag("BOOLEAN"), |_| {
+          Property::Literal(LiteralBaseType::Boolean.into())
+        }),
+        map(tag("TIMESTAMP"), |_| {
+          Property::Literal(LiteralBaseType::TimeStamp.into())
+        }),
+        map(parse_property_map, |property_map| {
+          Property::Map(property_map)
+        }),
+        map((tag("["), parse_property, tag("]")), |(_, property, _)| {
+          Property::Array(Box::new(property))
+        }),
+        map(parse_identifier, |name: &str| {
+          Property::Named(name.to_string())
+        }),
+      )),
+      opt(ws0(tag("?"))),
+    ),
+    |(p, q)| match q
+    {
+      Some(_) => Property::Optional(Box::new(p)),
+      None => p,
+    },
+  )
+  .parse(input)
+}
+
+fn parse_property_map(input: &str) -> VResult<&str, IndexMap<String, Property>>
+{
+  map(
+    (
+      tag("{"),
+      opt((
+        separated_list1(
+          ws0(tag(",")),
+          map(
+            (ws0(parse_identifier), ws0(tag(":")), ws0(parse_property)),
+            |(name, _, property)| (name.to_string(), property),
+          ),
+        ),
+        opt(ws0(tag(","))),
+      )),
+      opt(ws0(tag(","))),
+      ws0(tag("}")),
+    ),
+    |(_, properties, _, _)| {
+      properties
+        .map(|(x, _)| x.into_iter().collect())
+        .unwrap_or_default()
+    },
+  )
+  .parse(input)
+}
+
+/// parse a property definition
+fn parse_property_definition(input: &str) -> VResult<&str, ParseTreeElement>
+{
+  alt((
+    map(
+      (
+        parse_label,
+        ws0(tag("<:")),
+        ws0(parse_label),
+        ws0(parse_property_map),
+      ),
+      |(label, _, parent, properties)| ParseTreeElement::Property {
+        label: label.to_string(),
+        properties,
+        parent: Some(parent.to_string()),
+      },
+    ),
+    map(
+      (parse_label, ws0(parse_property_map)),
+      |(label, properties)| ParseTreeElement::Property {
+        label: label.to_string(),
+        properties,
+        parent: None,
+      },
+    ),
+  ))
+  .parse(input)
+}
+
+fn parse_node_definition(input: &str) -> VResult<&str, ParseTreeElement>
+{
+  map(
+    (tag("("), ws0(parse_label), ws0(tag(")"))),
+    |(_, label, _)| ParseTreeElement::Node {
+      label: label.to_string(),
+    },
+  )
+  .parse(input)
+}
+fn parse_edge_definition(input: &str) -> VResult<&str, ParseTreeElement>
+{
+  map(
+    (
+      tag("("),
+      ws0(parse_label),
+      ws0(tag(")-[")),
+      ws0(parse_label),
+      ws0(tag("]->(")),
+      ws0(parse_label),
+      ws0(tag(")")),
+    ),
+    |(_, source, _, label, _, destination, _)| ParseTreeElement::Edge {
+      source: source.to_string(),
+      label: label.to_string(),
+      destination: destination.to_string(),
+    },
+  )
+  .parse(input)
+}
+
+fn single_line_comment(input: &str) -> VResult<&str, ()>
+{
+  value((), (multispace0, tag("//"), is_not("\n\r"), multispace0)).parse(input)
+}
+
+/// parse the schema
+pub(crate) fn parse_schema(input: &str) -> VResult<&str, Vec<ParseTreeElement>>
+{
+  terminated(
+    separated_list0(
+      tag(","),
+      cut(ws0(delimited(
+        many0(single_line_comment),
+        alt((
+          parse_constrained_type_definition,
+          parse_property_definition,
+          parse_edge_definition,
+          parse_node_definition,
+        )),
+        many0(single_line_comment),
+      ))),
+    ),
+    multispace0,
+  )
+  .parse(input)
+}
+
+fn parse_integer(input: &str) -> VResult<&str, Value>
+{
+  map_res_failure(recognize(pair(opt(char('-')), digit1)), |s: &str| {
+    s.parse::<i64>().map(Value::Integer)
+  })
+  .parse(input)
+}
+
+fn parse_float(input: &str) -> VResult<&str, Value>
+{
+  map_res_failure(
+    recognize((
+      opt(char('-')),
+      digit1,
+      char('.'),
+      digit1,
+      opt((one_of("eE"), opt(one_of("+-")), digit1)),
+    )),
+    |s: &str| s.parse::<f64>().map(Value::Float),
+  )
+  .parse(input)
+}
+
+fn parse_boolean(input: &str) -> VResult<&str, Value>
+{
+  alt((
+    value(Value::Boolean(true), tag("true")),
+    value(Value::Boolean(false), tag("false")),
+  ))
+  .parse(input)
+}
+
+#[inline]
+fn is_label_char(chr: char) -> bool
+{
+  chr.is_alphanumeric() || chr == '_'
+}
+
+fn parse_quoted_string(input: &str) -> VResult<&str, String>
+{
+  delimited(
+    char('"'),
+    map(
+      opt(escaped_transform(
+        is_not("\"\\"),
+        '\\',
+        alt((value("\"", tag("\"")), value("\\", tag("\\")))),
+      )),
+      |s: Option<String>| s.unwrap_or_default(),
+    ),
+    cut(char('"')),
+  )
+  .parse(input)
+}
+
+fn parse_string_value(input: &str) -> VResult<&str, Value>
+{
+  alt((
+    // Try quoted string with potential timestamp
+    |input| {
+      parse_quoted_string(input).map(|(rest, s)| match graphcore::TimeStamp::parse(&s)
+      {
+        Ok(ts) => (rest, Value::TimeStamp(ts)),
+        Err(_) => (rest, Value::String(s)),
+      })
+    },
+    // Try unquoted label strings
+    map(take_while1(is_label_char), |s: &str| {
+      Value::String(s.to_string())
+    }),
+  ))
+  .parse(input)
+}
+
+fn iso_date(input: &str) -> VResult<&str, &str>
+{
+  recognize((
+    digit1,
+    char('-'),
+    fixed_digit::<2>,
+    char('-'),
+    fixed_digit::<2>,
+  ))
+  .parse(input)
+}
+
+fn iso_time(input: &str) -> VResult<&str, &str>
+{
+  recognize((
+    fixed_digit::<2>,
+    char(':'),
+    fixed_digit::<2>,
+    char(':'),
+    fixed_digit::<2>,
+    opt(pair(char('.'), digit1)),
+  ))
+  .parse(input)
+}
+
+fn iso_offset(input: &str) -> VResult<&str, &str>
+{
+  alt((
+    tag("Z"),
+    recognize((one_of("+-"), digit1, char(':'), digit1)),
+  ))
+  .parse(input)
+}
+
+fn iso_zone(input: &str) -> VResult<&str, &str>
+{
+  recognize(delimited(char('['), take_while1(|c| c != ']'), char(']'))).parse(input)
+}
+
+fn iso_timestamp(input: &str) -> VResult<&str, &str>
+{
+  recognize((iso_date, char('T'), iso_time, iso_offset, opt(iso_zone))).parse(input)
+}
+
+fn parse_timestamp_value(input: &str) -> VResult<&str, Value>
+{
+  map_res_failure(iso_timestamp, |s: &str| {
+    graphcore::TimeStamp::parse(s)
+      .map(Value::TimeStamp)
+      .map_err(|e| format!("invalid ISO 8601 timestamp '{s}': {e}"))
+  })
+  .parse(input)
+}
+
+pub(crate) fn parse_value(input: &str) -> VResult<&str, Value>
+{
+  alt((
+    parse_timestamp_value,
+    parse_float,
+    parse_integer,
+    parse_boolean,
+    parse_string_value,
+  ))
+  .parse(input)
+}
+
+fn parse_in_list(input: &str) -> VResult<&str, Vec<Value>>
+{
+  delimited(
+    ws0(char('[')),
+    separated_list1(ws0(char(',')), ws0(parse_value)),
+    ws0(cut(char(']'))),
+  )
+  .parse(input)
+}
+
+fn parse_atom(input: &str) -> VResult<&str, Constraint>
+{
+  alt((
+    delimited(ws0(char('(')), ws0(parse_or_expr), ws0(cut(char(')')))),
+    map(preceded(ws0(tag("IN")), ws0(parse_in_list)), Constraint::In),
+    map(preceded(ws0(tag("==")), ws0(parse_value)), Constraint::Eq),
+    map(preceded(ws0(tag("!=")), ws0(parse_value)), Constraint::Ne),
+    map(
+      preceded(ws0(tag("<=")), ws0(parse_value)),
+      Constraint::LessOrEqual,
+    ),
+    map(
+      preceded(ws0(tag(">=")), ws0(parse_value)),
+      Constraint::GreaterOrEqual,
+    ),
+    map(
+      preceded(ws0(char('<')), ws0(parse_value)),
+      Constraint::LessThan,
+    ),
+    map(
+      preceded(ws0(char('>')), ws0(parse_value)),
+      Constraint::GreaterThan,
+    ),
+  ))
+  .parse(input)
+}
+
+fn parse_unary(input: &str) -> VResult<&str, Constraint>
+{
+  alt((
+    map(preceded(ws0(char('!')), ws0(parse_unary)), |c| {
+      Constraint::Not(Box::new(c))
+    }),
+    parse_atom,
+  ))
+  .parse(input)
+}
+
+fn parse_and_expr(input: &str) -> VResult<&str, Constraint>
+{
+  map(
+    separated_list1(ws0(tag("&&")), ws0(parse_unary)),
+    |mut cs| {
+      if cs.len() == 1
+      {
+        cs.remove(0)
+      }
+      else
+      {
+        Constraint::And(cs)
+      }
+    },
+  )
+  .parse(input)
+}
+
+fn parse_or_expr(input: &str) -> VResult<&str, Constraint>
+{
+  map(
+    separated_list1(ws0(tag("||")), ws0(parse_and_expr)),
+    |mut cs| {
+      if cs.len() == 1
+      {
+        cs.remove(0)
+      }
+      else
+      {
+        Constraint::Or(cs)
+      }
+    },
+  )
+  .parse(input)
+}
+
+pub(crate) fn parse_constraint(input: &str) -> VResult<&str, Constraint>
+{
+  parse_or_expr(input)
+}
+
+/// Parse a type reference: either a base scalar type or a named type.
+pub(crate) fn parse_type_ref(input: &str) -> VResult<&str, crate::gqls::ast::TypeRef>
+{
+  use crate::gqls::ast::TypeRef;
+
+  alt((
+    map(tag("STRING"), |_| TypeRef::Base(LiteralBaseType::String)),
+    map(tag("FLOAT"), |_| TypeRef::Base(LiteralBaseType::Float)),
+    map(tag("INTEGER"), |_| TypeRef::Base(LiteralBaseType::Integer)),
+    map(tag("BOOLEAN"), |_| TypeRef::Base(LiteralBaseType::Boolean)),
+    map(tag("TIMESTAMP"), |_| {
+      TypeRef::Base(LiteralBaseType::TimeStamp)
+    }),
+    map(parse_label, |l: &str| TypeRef::Named(l.to_string())),
+  ))
+  .parse(input)
+}
+
+/// Parse a constrained type definition: `type Name = TypeRef: Constraint?,`
+/// or `type Name = TypeRef,`
+pub(crate) fn parse_constrained_type_definition(input: &str) -> VResult<&str, ParseTreeElement>
+{
+  use crate::gqls::ast::ConstrainedTypeDef;
+
+  map(
+    (
+      preceded(ws0(tag("type")), ws0(parse_label)),
+      ws0(char('=')),
+      ws0(parse_type_ref),
+      opt(preceded(ws0(char(':')), ws0(cut(parse_constraint)))),
+    ),
+    |(name, _, base, constraint)| ParseTreeElement::ConstrainedType {
+      name: name.to_string(),
+      def: ConstrainedTypeDef { base, constraint },
+    },
+  )
+  .parse(input)
+}
+
+#[cfg(test)]
+mod tests
+{
+  use std::assert_matches;
+
+  use crate::gqls::{ast, constraint::Constraint, parser::ParseTreeElement};
+  use graphcore::Value;
+
+  #[test]
+  fn test_single_line_comment()
+  {
+    assert!(super::single_line_comment("// hello").is_ok());
+    assert!(super::single_line_comment("// hello\n").is_ok());
+    assert!(super::single_line_comment("/ hello").is_err());
+    assert!(super::single_line_comment(" // hello").is_ok());
+    assert!(super::single_line_comment("\n // hello").is_ok());
+  }
+
+  #[test]
+  fn parses_positive_and_negative_integers()
+  {
+    assert_eq!(super::parse_value("42").unwrap().1, Value::Integer(42));
+    assert_eq!(super::parse_value("-42").unwrap().1, Value::Integer(-42));
+  }
+
+  #[test]
+  fn parses_float_with_and_without_exponent()
+  {
+    assert_eq!(super::parse_value("1.5").unwrap().1, Value::Float(1.5));
+    assert_eq!(super::parse_value("1.5e2").unwrap().1, Value::Float(150.0));
+    assert_eq!(super::parse_value("-0.5").unwrap().1, Value::Float(-0.5));
+  }
+
+  #[test]
+  fn rejects_malformed_float()
+  {
+    let (rest, v) = super::parse_value("1.2.3").unwrap();
+    assert_eq!(v, Value::Float(1.2));
+    assert_eq!(rest, ".3");
+  }
+
+  #[test]
+  fn parses_booleans()
+  {
+    assert_eq!(super::parse_value("true").unwrap().1, Value::Boolean(true));
+    assert_eq!(
+      super::parse_value("false").unwrap().1,
+      Value::Boolean(false)
+    );
+  }
+
+  #[test]
+  fn parses_bare_identifier_as_string()
+  {
+    assert_eq!(
+      super::parse_value("Context").unwrap().1,
+      Value::String("Context".into())
+    );
+  }
+
+  #[test]
+  fn parses_quoted_string_with_escapes()
+  {
+    assert_eq!(
+      super::parse_value(r#""needs a space""#).unwrap().1,
+      Value::String("needs a space".into())
+    );
+    assert_eq!(
+      super::parse_value(r#""say \"hi\"""#).unwrap().1,
+      Value::String(r#"say "hi""#.into())
+    );
+  }
+
+  #[test]
+  fn rejects_unterminated_quoted_string()
+  {
+    assert!(super::parse_value(r#""unterminated"#).is_err());
+  }
+
+  #[test]
+  fn parses_quoted_timestamp()
+  {
+    let (_, v) = super::parse_value(r#""2024-01-01T00:00:00.000000+00:00[UTC]""#).unwrap();
+    assert!(matches!(v, Value::TimeStamp(_)));
+  }
+
+  #[test]
+  fn parses_timestamp_with_z_offset()
+  {
+    let (_, v) = super::parse_value(r#"2024-01-01T00:00:00.000000+00:00[UTC]"#).unwrap();
+    assert!(matches!(v, Value::TimeStamp(_)));
+  }
+
+  #[test]
+  fn parses_timestamp_with_numeric_offset()
+  {
+    let (_, v) = super::parse_value(r#"2024-06-15T07:00:00.123000-00:00[GMT]"#).unwrap();
+    assert!(matches!(v, Value::TimeStamp(_)));
+  }
+
+  #[test]
+  fn rejects_timestamp_missing_offset()
+  {
+    assert!(super::parse_timestamp_value(r#"2024-01-01T00:00:00"#).is_err());
+  }
+
+  #[test]
+  fn rejects_malformed_timestamp_string()
+  {
+    assert!(super::parse_timestamp_value(r#"not-a-date"#).is_err());
+  }
+
+  #[test]
+  fn parses_in_operator()
+  {
+    let c = super::parse_constraint("IN [Context, Critical, Excluded]")
+      .unwrap()
+      .1;
+    assert_eq!(
+      c,
+      Constraint::In(vec![
+        Value::String("Context".into()),
+        Value::String("Critical".into()),
+        Value::String("Excluded".into()),
+      ])
+    );
+  }
+
+  #[test]
+  fn parses_each_comparison_operator()
+  {
+    assert_eq!(
+      super::parse_constraint("== 5").unwrap().1,
+      Constraint::Eq(Value::Integer(5))
+    );
+    assert_eq!(
+      super::parse_constraint("!= 5").unwrap().1,
+      Constraint::Ne(Value::Integer(5))
+    );
+    assert_eq!(
+      super::parse_constraint("< 5").unwrap().1,
+      Constraint::LessThan(Value::Integer(5))
+    );
+    assert_eq!(
+      super::parse_constraint("<= 5").unwrap().1,
+      Constraint::LessOrEqual(Value::Integer(5))
+    );
+    assert_eq!(
+      super::parse_constraint("> 5").unwrap().1,
+      Constraint::GreaterThan(Value::Integer(5))
+    );
+    assert_eq!(
+      super::parse_constraint(">= 5").unwrap().1,
+      Constraint::GreaterOrEqual(Value::Integer(5))
+    );
+  }
+
+  #[test]
+  fn two_char_operators_not_mis_parsed_as_prefix()
+  {
+    let (rest, c) = super::parse_constraint("<= 5").unwrap();
+    assert_eq!(rest, "");
+    assert_eq!(c, Constraint::LessOrEqual(Value::Integer(5)));
+  }
+
+  #[test]
+  fn and_binds_tighter_than_or()
+  {
+    let c = super::parse_constraint("> 0 || > 1 && < 10").unwrap().1;
+    assert_eq!(
+      c,
+      Constraint::Or(vec![
+        Constraint::GreaterThan(Value::Integer(0)),
+        Constraint::And(vec![
+          Constraint::GreaterThan(Value::Integer(1)),
+          Constraint::LessThan(Value::Integer(10)),
+        ]),
+      ])
+    );
+  }
+
+  #[test]
+  fn not_binds_tighter_than_and()
+  {
+    let c = super::parse_constraint("!(> 0) && < 10").unwrap().1;
+    assert_eq!(
+      c,
+      Constraint::And(vec![
+        Constraint::Not(Box::new(Constraint::GreaterThan(Value::Integer(0)))),
+        Constraint::LessThan(Value::Integer(10)),
+      ])
+    );
+  }
+
+  #[test]
+  fn parens_override_precedence()
+  {
+    let c = super::parse_constraint("(> 0 || > 1) && < 10").unwrap().1;
+    assert_eq!(
+      c,
+      Constraint::And(vec![
+        Constraint::Or(vec![
+          Constraint::GreaterThan(Value::Integer(0)),
+          Constraint::GreaterThan(Value::Integer(1)),
+        ]),
+        Constraint::LessThan(Value::Integer(10)),
+      ])
+    );
+  }
+
+  #[test]
+  fn rejects_unmatched_paren()
+  {
+    assert!(super::parse_constraint("(> 0").is_err());
+  }
+
+  #[test]
+  fn rejects_missing_operand()
+  {
+    assert!(super::parse_constraint(">").is_err());
+  }
+
+  #[test]
+  fn rejects_empty_in_list()
+  {
+    assert!(super::parse_constraint("IN []").is_err());
+  }
+
+  // Tests for parse_type_ref
+  #[test]
+  fn parses_base_type_string()
+  {
+    use crate::gqls::properties::LiteralBaseType;
+    let (_, tr) = super::parse_type_ref("STRING").unwrap();
+    assert_eq!(tr, crate::gqls::ast::TypeRef::Base(LiteralBaseType::String));
+  }
+
+  #[test]
+  fn parses_base_type_integer()
+  {
+    use crate::gqls::properties::LiteralBaseType;
+    let (_, tr) = super::parse_type_ref("INTEGER").unwrap();
+    assert_eq!(
+      tr,
+      crate::gqls::ast::TypeRef::Base(LiteralBaseType::Integer)
+    );
+  }
+
+  #[test]
+  fn parses_named_type_reference()
+  {
+    let (_, tr) = super::parse_type_ref("MyType").unwrap();
+    assert_eq!(tr, crate::gqls::ast::TypeRef::Named("MyType".to_string()));
+  }
+
+  #[test]
+  fn parses_declaration_without_constraint()
+  {
+    use crate::gqls::properties::LiteralBaseType;
+    let (_, tree_element) = super::parse_constrained_type_definition("type Age = INTEGER").unwrap();
+    assert_matches!(
+      tree_element,
+      ParseTreeElement::ConstrainedType {
+        name,
+        def: ast::ConstrainedTypeDef {
+          base: crate::gqls::ast::TypeRef::Base(LiteralBaseType::Integer),
+          constraint: None
+        }
+      } if name == "Age"
+    );
+  }
+
+  #[test]
+  fn parses_declaration_with_base_type_and_constraint()
+  {
+    use crate::gqls::properties::LiteralBaseType;
+    let (_, tree_element) =
+      super::parse_constrained_type_definition("type Bob = INTEGER: > 10").unwrap();
+    assert_matches!(
+      tree_element,
+      ParseTreeElement::ConstrainedType {
+        name,
+        def: ast::ConstrainedTypeDef {
+          base: crate::gqls::ast::TypeRef::Base(LiteralBaseType::Integer),
+          constraint: Some(Constraint::GreaterThan(Value::Integer(10))),
+        }
+      } if name == "Bob"
+    );
+  }
+
+  #[test]
+  fn parses_declaration_referencing_named_type()
+  {
+    let (_, tree_element) =
+      super::parse_constrained_type_definition("type SuperBob = Bob: < 20").unwrap();
+    assert_matches!(
+      tree_element,
+      ParseTreeElement::ConstrainedType {
+        name,
+        def: ast::ConstrainedTypeDef {
+          base: crate::gqls::ast::TypeRef::Named(base_type_name),
+          constraint: Some(Constraint::LessThan(Value::Integer(20))),
+        }
+      } if name == "SuperBob" && base_type_name == "Bob"
+    );
+  }
+
+  #[test]
+  fn parses_declaration_with_whitespace_variations()
+  {
+    use crate::gqls::properties::LiteralBaseType;
+    let (_, tree_element) =
+      super::parse_constrained_type_definition("  type  Age  =  INTEGER  :  > 10  ").unwrap();
+    assert_matches!(
+      tree_element,
+      ParseTreeElement::ConstrainedType {
+        name,
+        def: ast::ConstrainedTypeDef {
+          base: crate::gqls::ast::TypeRef::Base(LiteralBaseType::Integer),
+          constraint: Some(Constraint::GreaterThan(Value::Integer(10))),
+        }
+      } if name == "Age"
+    );
+  }
+}