Function plan_cast

src/sql/src/plan/typeconv.rs:1530–1567

Plans a cast between [`SqlScalarType`]s, specifying which types of casts are permitted using [`CastContext`]. # Errors If a cast between the `ScalarExpr`'s base type and the specified type is: - Not possible, e.g. `Bytes` to `Interval` - Not permitted, e.g. implicitly casting from `Float64` to `Float32`. - Not implemented yet

(
    ecx: &ExprContext,
    ccx: CastContext,
    expr: HirScalarExpr,
    to: &SqlScalarType,
)

/// - Not permitted, e.g. implicitly casting from `Float64` to `Float32`.
/// - Not implemented yet
pub fn plan_cast(
    ecx: &ExprContext,
    ccx: CastContext,
    expr: HirScalarExpr,
    to: &SqlScalarType,
) -> Result<HirScalarExpr, PlanError> {
    let from = ecx.scalar_type(&expr);

    // Close over `ccx`, `from`, and `to` to simplify error messages in the
    // face of intermediate expressions.
    let cast_inner = |from, to, expr| {
        get_cast(ecx, ccx, from, to)
            .map(|cast| cast(expr))
            .map_err(|e| e.into_plan_error(ecx.name.into()))
    };

    // Get cast which might include parameter rewrites + generating intermediate
    // expressions.
    //
    // String-like types get special handling to match PostgreSQL.
    // See: https://github.com/postgres/postgres/blob/6b04abdfc/
    //   src/backend/parser/parse_coerce.c#L3205-L3223
    let from_category = TypeCategory::from_type(&from);
    let to_category = TypeCategory::from_type(to);
    if from_category == TypeCategory::String && to_category != TypeCategory::String {
        // Converting from stringlike to something non-stringlike. Handle as if
        // `from` were a `SqlScalarType::String.
        cast_inner(&SqlScalarType::String, to, expr)
    } else if from_category != TypeCategory::String && to_category == TypeCategory::String {
        // Converting from non-stringlike to something stringlike. Convert to a
        // `SqlScalarType::String` and then to the desired type.
        let expr = cast_inner(&from, &SqlScalarType::String, expr)?;
        cast_inner(&SqlScalarType::String, to, expr)
    } else {
        // Standard cast.
        cast_inner(&from, to, expr)
    }
}

/// Reports whether it is possible to perform a cast from the specified types.
pub fn can_cast(