Function try_plan_derived_from

nodedb-sql/src/planner/select/select_stmt.rs:373–426

Desugar `FROM (SELECT ...) AS alias` into a synthetic single-CTE plan. Recognises the single-source, non-LATERAL derived-table pattern. The inner subquery is planned with the original catalog; the outer SELECT is replanned with a `CteCatalog` that resolves the alias to a schemaless source. The result is wrapped as `SqlPlan::Cte` so the `convert_cte` lowering takes care of execution. Returns `Ok(

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

/// Returns `Ok(None)` when the FROM clause is not a single derived
/// table, so the caller falls through to the regular planning path.
fn try_plan_derived_from(
    select: &Select,
    catalog: &dyn SqlCatalog,
    functions: &FunctionRegistry,
    temporal: TemporalScope,
) -> Result<Option<SqlPlan>> {
    if select.from.len() != 1 {
        return Ok(None);
    }
    let from = &select.from[0];
    if !from.joins.is_empty() {
        return Ok(None);
    }
    let (subquery, alias_ident) = match &from.relation {
        ast::TableFactor::Derived {
            lateral: false,
            subquery,
            alias: Some(alias),
            ..
        } => (subquery, alias),
        _ => return Ok(None),
    };

    let alias_name = normalize_ident(&alias_ident.name);
    let inner_plan = plan_query(subquery, catalog, functions, temporal)?;

    // Replan the outer SELECT against a catalog that resolves the alias
    // as a schemaless source. The outer can reference `alias.col`
    // qualified or unqualified — the resolver treats CTE rows as a
    // schemaless document so any projected column flows through.
    let derived_catalog = CteCatalog {
        inner: catalog,
        cte_names: vec![alias_name.clone()],
    };
    let mut outer_select = select.clone();
    outer_select.from[0].relation = ast::TableFactor::Table {
        name: ast::ObjectName::from(vec![ast::Ident::new(alias_name.clone())]),
        alias: None,
        args: None,
        with_hints: Vec::new(),
        version: None,
        with_ordinality: false,
        partitions: Vec::new(),
        json_path: None,
        sample: None,
        index_hints: Vec::new(),
    };
    let outer_plan = plan_select(&outer_select, &derived_catalog, functions, temporal)?;

    Ok(Some(SqlPlan::Cte {
        definitions: vec![(alias_name, inner_plan)],
        outer: Box::new(outer_plan),
    }))
}

/// Dispatch to the JOIN planner if the FROM contains joins.
fn try_plan_join(