Function plan_join_from_select

nodedb-sql/src/planner/join/plan.rs:18–151

(
    select: &Select,
    scope: &TableScope,
    catalog: &dyn SqlCatalog,
    functions: &FunctionRegistry,
    temporal: crate::TemporalScope,
)

use crate::types::*;

pub fn plan_join_from_select(
    select: &Select,
    scope: &TableScope,
    catalog: &dyn SqlCatalog,
    functions: &FunctionRegistry,
    temporal: crate::TemporalScope,
) -> Result<Option<SqlPlan>> {
    let from = &select.from[0];

    // Left side: either an ARRAY_* TVF or a named table.
    let left_plan =
        if let Some(plan) = array_arm::try_plan_relation(&from.relation, catalog, temporal)? {
            plan
        } else {
            scan_for_relation(&from.relation, scope)?
        };

    let outer_alias = scan_alias_from_relation(&from.relation);

    let mut current_plan = left_plan;

    for join_item in &from.joins {
        // Detect LATERAL derived subquery on the right side.
        if is_lateral_derived(&join_item.relation) {
            let lateral_alias =
                lateral_alias_from_factor(&join_item.relation).ok_or_else(|| {
                    SqlError::Unsupported {
                        detail: "LATERAL subquery requires an alias (e.g. LATERAL (...) AS x)"
                            .into(),
                    }
                })?;
            let subquery = subquery_from_factor(&join_item.relation)
                .expect("is_lateral_derived guarantees Derived variant");
            let left_join = is_left_join_operator(&join_item.join_operator);
            let projection = super::super::select::convert_projection(&select.projection)?;
            return Ok(Some(plan_lateral_join(
                current_plan,
                outer_alias,
                subquery,
                &lateral_alias,
                left_join,
                projection,
                catalog,
                functions,
                temporal,
            )?));
        }

        // Right side: array TVF or named table.
        let right_plan = if let Some(plan) =
            array_arm::try_plan_relation(&join_item.relation, catalog, temporal)?
        {
            plan
        } else {
            scan_for_relation(&join_item.relation, scope)?
        };

        let (join_type, on_keys, condition) = extract_join_spec(&join_item.join_operator)?;