Method create_placeholder_expr

datafusion/sql/src/expr/value.rs:106–149

Create a placeholder expression Both named (`$foo`) and positional (`$1`, `$2`, ...) placeholder styles are supported.

(
        param: String,
        param_data_types: &[Option<FieldRef>],
    )

    /// Create a placeholder expression
    /// Both named (`$foo`) and positional (`$1`, `$2`, ...) placeholder styles are supported.
    fn create_placeholder_expr(
        param: String,
        param_data_types: &[Option<FieldRef>],
    ) -> Result<Expr> {
        // Try to parse the placeholder as a number. If the placeholder does not have a valid
        // positional value, assume we have a named placeholder.
        let index = param[1..].parse::<usize>();
        let idx = match index {
            Ok(0) => {
                return plan_err!(
                    "Invalid placeholder, zero is not a valid index: {param}"
                );
            }
            Ok(index) => index - 1,
            Err(_) => {
                return if param_data_types.is_empty() {
                    Ok(Expr::Placeholder(Placeholder::new_with_field(param, None)))
                } else {
                    // FIXME: This branch is shared by params from PREPARE and CREATE FUNCTION, but
                    // only CREATE FUNCTION currently supports named params. For now, we rewrite
                    // these to positional params.
                    let named_param_pos = param_data_types.iter().position(|v| {
                        v.as_ref().is_some_and(|field| field.name() == &param[1..])
                    });
                    match named_param_pos {
                        Some(pos) => Ok(Expr::Placeholder(Placeholder::new_with_field(
                            format!("${}", pos + 1),
                            param_data_types.get(pos).and_then(|v| v.clone()),
                        ))),
                        None => plan_err!("Unknown placeholder: {param}"),
                    }
                };
            }
        };
        // Check if the placeholder is in the parameter list
        // FIXME: In the CREATE FUNCTION branch, param_type = None should raise an error
        let param_type = param_data_types.get(idx).and_then(|v| v.clone());
        // Data type of the parameter
        debug!("type of param {param} param_data_types[idx]: {param_type:?}");

        Ok(Expr::Placeholder(Placeholder::new_with_field(
            param, param_type,
        )))
    }

    pub(super) fn sql_array_literal(
        &self,