feat: compile PromQL comparisons and set operators

crates/asap-aware-mapping/src/query_physical_lowering.rs

@@ -1029,7 +1029,7 @@ fn promql_binary_operation(
         BinaryOpKind::Set(PromQLVectorSetOpKind::And) => PromqlBinaryOperation::And,
         BinaryOpKind::Set(PromQLVectorSetOpKind::Or) => PromqlBinaryOperation::Or,
         BinaryOpKind::Set(PromQLVectorSetOpKind::Unless) => PromqlBinaryOperation::Unless,
-        BinaryOpKind::Arithmetic(_) | BinaryOpKind::Compare(_) => {
+        BinaryOpKind::Arithmetic(_) | BinaryOpKind::Compare(_) | BinaryOpKind::CompareBool(_) => {
             PromqlBinaryOperation::ArithmeticOrComparison
         }
     }

crates/asap-physical-operators/src/expressions/arithmetic.rs

@@ -25,7 +25,7 @@ pub fn evaluate_binary(
     right: f64,
 ) -> Result<crate::values::Value, crate::Error> {
     use crate::{values::Value, Error};
-    use planner_types::pre_asap::{ArithmeticOpKind, BinaryOpKind, CompareOpKind};
+    use planner_types::pre_asap::{ArithmeticOpKind, BinaryOpKind};
     let invalid =
         || Error::Invalid("unsupported binary operation or invalid checked-division domain".into());
     if operator.vector_match.is_some() {
@@ -49,15 +49,28 @@ pub fn evaluate_binary(
         BinaryOpKind::Arithmetic(ref op) => {
             Value::Float64(evaluate_float64_arithmetic(op, left, right))
         }
-        BinaryOpKind::Compare(ref op) => Value::Bool(match op {
-            CompareOpKind::Eq => left == right,
-            CompareOpKind::Ne => left != right,
-            CompareOpKind::Lt => left < right,
-            CompareOpKind::Le => left <= right,
-            CompareOpKind::Gt => left > right,
-            CompareOpKind::Ge => left >= right,
-            _ => return Err(invalid()),
-        }),
+        BinaryOpKind::Compare(ref op) => Value::Bool(compare(op, left, right).ok_or_else(invalid)?),
+        BinaryOpKind::CompareBool(ref op) => {
+            Value::Float64(if compare(op, left, right).ok_or_else(invalid)? {
+                1.
+            } else {
+                0.
+            })
+        }
         _ => return Err(invalid()),
     })
 }
+
+/// IEEE comparison, as Go's: NaN is unequal to everything, itself included.
+fn compare(op: &planner_types::pre_asap::CompareOpKind, left: f64, right: f64) -> Option<bool> {
+    use planner_types::pre_asap::CompareOpKind;
+    Some(match op {
+        CompareOpKind::Eq => left == right,
+        CompareOpKind::Ne => left != right,
+        CompareOpKind::Lt => left < right,
+        CompareOpKind::Le => left <= right,
+        CompareOpKind::Gt => left > right,
+        CompareOpKind::Ge => left >= right,
+        _ => return None,
+    })
+}

crates/asap-physical-operators/src/expressions/mod.rs

@@ -87,6 +87,14 @@ impl Expression {
                         | CompareOpKind::Gt
                         | CompareOpKind::Ge,
                     ) => DataType::Bool,
+                    BinaryOpKind::CompareBool(
+                        CompareOpKind::Eq
+                        | CompareOpKind::Ne
+                        | CompareOpKind::Lt
+                        | CompareOpKind::Le
+                        | CompareOpKind::Gt
+                        | CompareOpKind::Ge,
+                    ) => DataType::Float64,
                     _ => return Err(invalid("unsupported binary operation")),
                 };
                 Ok((dtype, n || m))

crates/asap-physical-operators/src/operators/mod.rs

@@ -85,6 +85,7 @@ enum Kind {
     },
     SeriesBinary {
         operator: planner_types::post_asap::BinaryOperator,
+        scalars: [bool; 2],
     },
     Project(Vec<Expression>),
     Filter(Expression),