[query-engine] Add support for parsing KQL logical expressions (open-telemetry#578)

## Changes

* Adds support for parsing KQL logical expressions into query engine
expressions

Author: CodeBlanch

rust/experimental/query_engine/expressions/src/lib.rs

@@ -1,4 +1,5 @@
 pub(crate) mod expression;
+pub(crate) mod logical_expressions;
 pub(crate) mod scalar_expressions;
 pub(crate) mod value_accessor;
 
@@ -8,4 +9,5 @@ pub use expression::QueryLocation;
 pub use value_accessor::ValueAccessor;
 pub use value_accessor::ValueSelector;
 
+pub use logical_expressions::*;
 pub use scalar_expressions::*;

rust/experimental/query_engine/expressions/src/logical_expressions.rs

@@ -0,0 +1,210 @@
+use crate::{Expression, QueryLocation, ScalarExpression};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum LogicalExpression {
+    /// Resolve the boolean value for the logical expression using the inner
+    /// scalar expression.
+    ///
+    /// Note: To be valid the inner expression should be a
+    /// [`ScalarExpression::Boolean`] value or a resolved
+    /// ([`ScalarExpression::Attached`], [`ScalarExpression::Source`], or
+    /// [`ScalarExpression::Variable`]) value which is a boolean.
+    Scalar(ScalarExpression),
+
+    /// Returns true if two [`ScalarExpression`] are equal.
+    EqualTo(EqualToLogicalExpression),
+
+    /// Returns true if a [`ScalarExpression`] is greater than another
+    /// [`ScalarExpression`].
+    GreaterThan(GreaterThanLogicalExpression),
+
+    /// Returns true if a [`ScalarExpression`] is greater than or equal to
+    /// another [`ScalarExpression`].
+    GreaterThanOrEqualTo(GreaterThanOrEqualToLogicalExpression),
+
+    /// Returns true if the inner logical expression returns false.
+    Not(NotLogicalExpression),
+
+    /// Returns the result of a sequence of logical expressions chained using
+    /// logical `AND(&&)` and/or `OR(||)` operations.
+    Chain(ChainLogicalExpression),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct ChainLogicalExpression {
+    query_location: QueryLocation,
+    first_expression: Box<LogicalExpression>,
+    chain_expressions: Vec<ChainedLogicalExpression>,
+}
+
+impl ChainLogicalExpression {
+    pub fn new(
+        query_location: QueryLocation,
+        first_expression: LogicalExpression,
+    ) -> ChainLogicalExpression {
+        Self {
+            query_location,
+            first_expression: first_expression.into(),
+            chain_expressions: Vec::new(),
+        }
+    }
+
+    pub fn push_or(&mut self, expression: LogicalExpression) {
+        self.chain_expressions
+            .push(ChainedLogicalExpression::Or(expression));
+    }
+
+    pub fn push_and(&mut self, expression: LogicalExpression) {
+        self.chain_expressions
+            .push(ChainedLogicalExpression::And(expression));
+    }
+
+    pub fn get_expressions(&self) -> (&LogicalExpression, &Vec<ChainedLogicalExpression>) {
+        (&self.first_expression, &self.chain_expressions)
+    }
+}
+
+impl Expression for ChainLogicalExpression {
+    fn get_query_location(&self) -> &QueryLocation {
+        &self.query_location
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ChainedLogicalExpression {
+    Or(LogicalExpression),
+    And(LogicalExpression),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct EqualToLogicalExpression {
+    query_location: QueryLocation,
+    left: ScalarExpression,
+    right: ScalarExpression,
+}
+
+impl EqualToLogicalExpression {
+    pub fn new(
+        query_location: QueryLocation,
+        left: ScalarExpression,
+        right: ScalarExpression,
+    ) -> EqualToLogicalExpression {
+        Self {
+            query_location,
+            left,
+            right,
+        }
+    }
+
+    pub fn get_left(&self) -> &ScalarExpression {
+        &self.left
+    }
+
+    pub fn get_right(&self) -> &ScalarExpression {
+        &self.right
+    }
+}
+
+impl Expression for EqualToLogicalExpression {
+    fn get_query_location(&self) -> &QueryLocation {
+        &self.query_location
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct GreaterThanLogicalExpression {
+    query_location: QueryLocation,
+    left: ScalarExpression,
+    right: ScalarExpression,
+}
+
+impl GreaterThanLogicalExpression {
+    pub fn new(
+        query_location: QueryLocation,
+        left: ScalarExpression,
+        right: ScalarExpression,
+    ) -> GreaterThanLogicalExpression {
+        Self {
+            query_location,
+            left,
+            right,
+        }
+    }
+
+    pub fn get_left(&self) -> &ScalarExpression {
+        &self.left
+    }
+
+    pub fn get_right(&self) -> &ScalarExpression {
+        &self.right
+    }
+}
+
+impl Expression for GreaterThanLogicalExpression {
+    fn get_query_location(&self) -> &QueryLocation {
+        &self.query_location
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct GreaterThanOrEqualToLogicalExpression {
+    query_location: QueryLocation,
+    left: ScalarExpression,
+    right: ScalarExpression,
+}
+
+impl GreaterThanOrEqualToLogicalExpression {
+    pub fn new(
+        query_location: QueryLocation,
+        left: ScalarExpression,
+        right: ScalarExpression,
+    ) -> GreaterThanOrEqualToLogicalExpression {
+        Self {
+            query_location,
+            left,
+            right,
+        }
+    }
+
+    pub fn get_left(&self) -> &ScalarExpression {
+        &self.left
+    }
+
+    pub fn get_right(&self) -> &ScalarExpression {
+        &self.right
+    }
+}
+
+impl Expression for GreaterThanOrEqualToLogicalExpression {
+    fn get_query_location(&self) -> &QueryLocation {
+        &self.query_location
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct NotLogicalExpression {
+    query_location: QueryLocation,
+    inner_expression: Box<LogicalExpression>,
+}
+
+impl NotLogicalExpression {
+    pub fn new(
+        query_location: QueryLocation,
+        inner_expression: LogicalExpression,
+    ) -> NotLogicalExpression {
+        Self {
+            query_location,
+            inner_expression: inner_expression.into(),
+        }
+    }
+
+    pub fn get_inner_expression(&self) -> &LogicalExpression {
+        &self.inner_expression
+    }
+}
+
+impl Expression for NotLogicalExpression {
+    fn get_query_location(&self) -> &QueryLocation {
+        &self.query_location
+    }
+}

rust/experimental/query_engine/expressions/src/scalar_expressions.rs

@@ -1,6 +1,6 @@
 use chrono::{DateTime, FixedOffset};
 
-use crate::{Expression, QueryLocation, ValueAccessor, ValueSelector};
+use crate::{Expression, LogicalExpression, QueryLocation, ValueAccessor, ValueSelector};
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum ScalarExpression {
@@ -43,6 +43,9 @@ pub enum ScalarExpression {
 
     /// Negate the value returned by the inner scalar expression.
     Negate(NegateScalarExpression),
+
+    /// Boolean value returned by the inner logical expression.
+    Logical(Box<LogicalExpression>),
 }
 
 #[derive(Debug, Clone, PartialEq)]

rust/experimental/query_engine/kql-parser/src/kql.pest

@@ -6,6 +6,14 @@ minus_token = { "-" }
 plus_token = { "+" }
 positive_infinity_token = { "+inf" }
 negative_infinity_token = { "-inf" }
+equals_token = @{ "==" }
+not_equals_token = @{ "!=" }
+greater_than_token = @{ ">" ~ !"=" }
+greater_than_or_equal_to_token = @{ ">=" }
+less_than_token = @{ "<" ~ !"=" }
+less_than_or_equal_to_token = @{ "<=" }
+and_token = @{ "and" }
+or_token = @{ "or" }
 
 // Literals
 true_literal = @{ "true" | "True" | "TRUE" }
@@ -40,6 +48,16 @@ identifier_literal = @{ ("_" | ASCII_ALPHA) ~ ("_" | ASCII_ALPHANUMERIC)* }
 real_expression = { "real(" ~ (positive_infinity_token|negative_infinity_token|double_literal|integer_literal) ~ ")" }
 datetime_expression = { "datetime(" ~ datetime_literal ~ ")" }
 
+comparison_expression = { scalar_expression ~ (equals_token|not_equals_token|greater_than_token|greater_than_or_equal_to_token|less_than_token|less_than_or_equal_to_token) ~ scalar_expression }
+scalar_expression = {
+    (real_expression | datetime_expression | boolean_expression | double_literal | integer_literal | string_literal | accessor_expression)
+    | ("(" ~ scalar_expression ~ ")")
+    | ("(" ~ logical_expression ~ ")")
+}
+boolean_expression = _{ true_literal | false_literal }
+logical_expressions = _{ comparison_expression|boolean_expression|accessor_expression }
+logical_expression = { (logical_expressions|("(" ~ logical_expression ~ ")")) ~ ((and_token|or_token) ~ logical_expression)* }
+
 accessor_index = _{ "[" ~ (integer_literal | string_literal | (minus_token? ~ accessor_expression)) ~ "]" }
 accessor = _{ identifier_literal ~ accessor_index? }
 accessor_expression = { accessor ~ (("." ~ accessor)|accessor_index)* }