feat(frontend-sql): recognize the SQL frequency L2 and entropy idioms

Port of the parked #562 and #564 for #509 Example 2. The SQL frontend
names `SQRT(SUM(c*c))` over Float64 grouped unit counts as FrequencyL2,
and `-SUM(p*LN(p))` with `p = COUNT(*)*1.0 / SUM(COUNT(*)) OVER ()` as
FrequencyEntropy converted to nats. An exact population count guards
SQL's empty-input NULL. Integer products, nullable keys, filters, HAVING,
other log bases and partial windows are refused.

The rules are the old Pass 1 SemanticEquivalentRewriteStrategy rules, run
by lower_sql at the query root so the Stage 1 pipeline sees the intents;
the exact candidate is the native exact reducer. The executor gains SQL
sqrt (from #562).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: zzylol

Cargo.lock

@@ -127,6 +127,16 @@ pub(super) fn evaluate(
                     .collect::<Result<Vec<_>, _>>()?;
                 return Ok(Value::Float64(promql_function(name, &values)?));
             }
+            if name.eq_ignore_ascii_case("sqrt") {
+                return match evaluate(&args[0], row, schema)? {
+                    Value::Null => Ok(Value::Null),
+                    Value::Float64(value) => Ok(Value::Float64(value.sqrt())),
+                    Value::Int64(value) => Ok(Value::Float64((value as f64).sqrt())),
+                    _ => Err(Error::Invalid(
+                        "SQL sqrt requires a numeric argument".into(),
+                    )),
+                };
+            }
             if name == "promql_drop_metric_name" {
                 let Value::Utf8(encoded) = evaluate(&args[0], row, schema)? else {
                     return Err(Error::Invalid("series identity must be Utf8".into()));
@@ -646,7 +656,19 @@ fn validate(expr: &ScalarExpr, schema: &planner_types::ir::schema::Schema) -> Re
             Ok(())
         }
         ScalarExpr::FunctionCall { name, args } => {
-            if name != "promql_drop_metric_name"
+            if name.eq_ignore_ascii_case("sqrt") {
+                if args.len() != 1
+                    || !matches!(
+                        args[0]
+                            .scalar_type(schema)
+                            .map_err(|e| Error::Invalid(e.to_string()))?
+                            .0,
+                        DataType::Int64 | DataType::Float64 | DataType::Null
+                    )
+                {
+                    return Err(invalid());
+                }
+            } else if name != "promql_drop_metric_name"
                 && planner_types::ir::scalar::scalar_type_rules::promql_function_arity(name)
                     .is_none()
                 && name != "asap_struct_field"

crates/executor/src/expressions/planner.rs

@@ -915,3 +915,33 @@ fn exact_cardinality_grouping_normalizes_float_identities() {
         [Value::Int64(2), Value::Int64(0)]
     ));
 }
+
+// SQL SQRT propagates NULL and accepts numeric inputs with a floating result.
+#[test]
+fn sql_sqrt_executes_numeric_and_null_arguments() {
+    for (dtype, value, expected) in [
+        (DataType::Int64, Value::Int64(9), 3.0),
+        (DataType::Float64, Value::Float64(2.25), 1.5),
+    ] {
+        let input = schema(&[("v", dtype, true)]);
+        let expression = ScalarExpr::FunctionCall {
+            name: "sqrt".into(),
+            args: vec![ScalarExpr::Column(0)],
+        };
+        let compiled = CompiledExpression::compile(&expression, &input).unwrap();
+        assert!(matches!(compiled.evaluate(&[value]).unwrap(), Value::Float64(v) if v == expected));
+        assert!(matches!(
+            compiled.evaluate(&[Value::Null]).unwrap(),
+            Value::Null
+        ));
+    }
+    let input = schema(&[("v", DataType::Float64, false)]);
+    let expression = ScalarExpr::FunctionCall {
+        name: "sqrt".into(),
+        args: vec![ScalarExpr::Column(0)],
+    };
+    let compiled = CompiledExpression::compile(&expression, &input).unwrap();
+    assert!(
+        matches!(compiled.evaluate(&[Value::Float64(-1.0)]).unwrap(), Value::Float64(v) if v.is_nan())
+    );
+}