icydb-core 0.261.7

//! Module: sql::lowering::predicate
//! Responsibility: lower SQL boolean expressions into predicate and planner expression forms.
//! Does not own: predicate normalization semantics or executor route selection.
//! Boundary: translates parser SQL shapes onto runtime predicate/query-plan authorities.

mod normalize;
#[cfg(test)]
mod tests;
mod validate;

use crate::db::query::preparation::PreparationWork;
use crate::db::{
    predicate::Predicate,
    query::plan::expr::{
        Expr, derive_normalized_bool_expr_predicate_subset, is_normalized_bool_expr,
    },
    sql::{
        lowering::{
            SqlLoweringError,
            expr::{SqlExprPhase, lower_sql_expr},
        },
        parser::SqlExpr,
    },
};

// Lower one parser-owned SQL `WHERE` expression onto the runtime predicate
// authority through the shared SQL-expression seam.
pub(in crate::db::sql::lowering) fn lower_sql_where_expr(
    expr: &SqlExpr,
    work: &PreparationWork<'_>,
) -> Result<Predicate, SqlLoweringError> {
    let lowered_expr = lower_sql_where_bool_expr(expr, work)?;

    derive_sql_where_expr_predicate_subset(&lowered_expr, work)?
        .ok_or_else(SqlLoweringError::unsupported_where_expression)
}

// Derive the predicate subset for one already-lowered SQL WHERE expression.
pub(in crate::db::sql::lowering) fn derive_sql_where_expr_predicate_subset(
    lowered_expr: &Expr,
    work: &PreparationWork<'_>,
) -> Result<Option<Predicate>, crate::db::QueryError> {
    derive_normalized_bool_expr_predicate_subset(lowered_expr, work)
}

// Lower one parser-owned SQL boolean expression onto the shared planner-owned
// WHERE boolean seam without compiling it into the runtime predicate layer.
pub(in crate::db::sql::lowering) fn lower_sql_where_bool_expr(
    expr: &SqlExpr,
    work: &PreparationWork<'_>,
) -> Result<Expr, SqlLoweringError> {
    lower_sql_bool_expr_internal(expr, false, SqlExprPhase::Where, work)
}

// Lower one SQL boolean expression that uses WHERE admission rules but does
// not own the top-level WHERE-only text-predicate casefold compatibility path.
pub(in crate::db::sql::lowering) fn lower_sql_pre_aggregate_bool_expr(
    expr: &SqlExpr,
    work: &PreparationWork<'_>,
) -> Result<Expr, SqlLoweringError> {
    lower_sql_bool_expr_internal(expr, false, SqlExprPhase::PreAggregate, work)
}

// Lower one parser-owned SQL scalar-row boolean expression through the
// bounded scalar searched-`CASE` canonicalization seam without changing the
// grouped or aggregate filter-expression surfaces.
pub(in crate::db::sql::lowering) fn lower_sql_scalar_where_bool_expr(
    expr: &SqlExpr,
    work: &PreparationWork<'_>,
) -> Result<Expr, SqlLoweringError> {
    lower_sql_bool_expr_internal(expr, true, SqlExprPhase::Where, work)
}

fn lower_sql_bool_expr_internal(
    expr: &SqlExpr,
    scalar_case_canonicalization: bool,
    phase: SqlExprPhase,
    work: &PreparationWork<'_>,
) -> Result<Expr, SqlLoweringError> {
    let expr = lower_sql_expr(expr, phase, work)?;
    validate::validate_where_bool_expr(&expr)?;
    let expr = if scalar_case_canonicalization {
        normalize::normalize_scalar_where_bool_expr(expr, work)?
    } else {
        normalize::normalize_where_bool_expr(expr, work)?
    };

    debug_assert!(
        validate::validate_where_bool_expr(&expr).is_ok(),
        "WHERE normalization must not widen or narrow clause admissibility",
    );

    debug_assert!(is_normalized_bool_expr(&expr));

    Ok(expr)
}