Method apply_coercion_strategy

graphlite/src/exec/executor.rs:8157–8237

ROADMAP v0.5.0 - Coercion strategy selection

(
        &self,
        value: &Value,
        _from_type: &GqlType,
        to_type: &GqlType,
        strategy: &CoercionStrategy,
    )

    /// Apply a specific coercion strategy to convert a value
    #[allow(dead_code)] // ROADMAP v0.5.0 - Coercion strategy selection
    fn apply_coercion_strategy(
        &self,
        value: &Value,
        _from_type: &GqlType,
        to_type: &GqlType,
        strategy: &CoercionStrategy,
    ) -> Result<Value, ExecutionError> {
        match strategy {
            CoercionStrategy::None => Ok(value.clone()),

            CoercionStrategy::IntegerWidening => {
                // Value should already be compatible for integer widening
                Ok(value.clone())
            }

            CoercionStrategy::IntegerToDecimal => {
                // Convert integer to decimal representation
                match value {
                    Value::Number(n) => Ok(Value::Number(*n)),
                    _ => Ok(value.clone()),
                }
            }

            CoercionStrategy::IntegerToFloat => {
                // Convert integer to float
                match value {
                    Value::Number(n) => Ok(Value::Number(*n)),
                    _ => Ok(value.clone()),
                }
            }

            CoercionStrategy::FloatWidening => {
                // Float widening preserves value
                Ok(value.clone())
            }

            CoercionStrategy::StringToOther => {
                // Convert string to target type
                match (value, to_type) {
                    (Value::String(s), GqlType::Integer) => s
                        .parse::<i64>()
                        .map(|i| Value::Number(i as f64))
                        .map_err(|_| {
                            ExecutionError::RuntimeError(format!(
                                "Cannot coerce '{}' to integer",
                                s
                            ))
                        }),
                    (Value::String(s), GqlType::Double) => {
                        s.parse::<f64>().map(Value::Number).map_err(|_| {
                            ExecutionError::RuntimeError(format!("Cannot coerce '{}' to number", s))
                        })
                    }
                    (Value::String(s), GqlType::Boolean) => match s.to_lowercase().as_str() {
                        "true" => Ok(Value::Boolean(true)),
                        "false" => Ok(Value::Boolean(false)),
                        _ => Err(ExecutionError::RuntimeError(format!(
                            "Cannot coerce '{}' to boolean",