icydb-core 0.264.7

//! Module: executor::projection::eval
//! Responsibility: shared projection expression error taxonomy and scalar evaluation helpers.
//! Does not own: generic test evaluators, expression type inference, or planner semantic validation policy.
//! Boundary: production execution stays on compiled scalar programs while test
//! helpers exercise the same compiled evaluator paths directly.

mod contracts;
#[cfg(test)]
mod missing_paths_tests;
#[cfg(test)]
mod residual_filters_tests;
mod scalar;

use crate::{
    db::{data::CanonicalSlotReader, executor::budget::charge_current_execution_budget},
    error::InternalError,
    value::Value,
};
use icydb_diagnostic_code::DiagnosticExecutionBudgetResource;
use std::borrow::Cow;

use self::contracts::EffectiveRuntimeFilterProgram;
pub(in crate::db) use contracts::ProjectionEvalError;
pub(in crate::db::executor) use scalar::eval_compiled_expr_with_required_slot_reader_cow;
pub(in crate::db::executor) use scalar::eval_compiled_expr_with_value_reader;
pub(in crate::db::executor) use scalar::eval_compiled_expr_with_value_ref_reader;
pub(in crate::db) use scalar::{
    eval_compiled_filter_expr_with_required_slot_reader,
    eval_compiled_filter_expr_with_value_cow_reader,
};

// Evaluate one planner-selected effective runtime filter program directly
// against a canonical structural slot reader. This is the scan-time lane used
// before raw rows are reduced to retained `Value` slots, so field-path filters
// can resolve nested value-storage payloads without planner/index pushdown.
pub(in crate::db::executor) fn eval_effective_runtime_filter_program_with_slot_reader(
    filter_program: &EffectiveRuntimeFilterProgram,
    slots: &dyn CanonicalSlotReader,
) -> Result<bool, InternalError> {
    charge_current_execution_budget(
        DiagnosticExecutionBudgetResource::PredicateExpressionSteps,
        1,
    )?;
    let predicate_program = filter_program.predicate_program();
    if let Some(predicate_program) = predicate_program
        && !predicate_program.eval_with_structural_slot_reader(slots)?
    {
        return Ok(false);
    }

    let Some(filter_expr) = filter_program.expression_filter() else {
        return predicate_program
            .map(|_| true)
            .ok_or_else(InternalError::query_executor_invariant);
    };

    eval_compiled_filter_expr_with_required_slot_reader(filter_expr, slots)
}

// Evaluate one planner-selected effective runtime filter program through one
// slot reader that may return borrowed or owned values. This keeps predicate
// evaluation on the canonical cow-reader path while letting expression-backed
// residual filters reuse the same TRUE-only boolean admission seam.
pub(in crate::db::executor) fn eval_effective_runtime_filter_program_with_value_cow_reader<'a, F>(
    filter_program: &EffectiveRuntimeFilterProgram,
    read_slot: &mut F,
) -> Result<bool, InternalError>
where
    F: FnMut(usize) -> Option<Cow<'a, Value>>,
{
    charge_current_execution_budget(
        DiagnosticExecutionBudgetResource::PredicateExpressionSteps,
        1,
    )?;
    let predicate_program = filter_program.predicate_program();
    if let Some(predicate_program) = predicate_program
        && !predicate_program.eval_with_slot_value_cow_reader(read_slot)
    {
        return Ok(false);
    }

    let Some(filter_expr) = filter_program.expression_filter() else {
        return predicate_program
            .map(|_| true)
            .ok_or_else(InternalError::query_executor_invariant);
    };

    eval_compiled_filter_expr_with_value_cow_reader(filter_expr, read_slot)
}