Method execute_declare_statement

graphlite/src/exec/executor.rs:8540–8598

Execute DECLARE statement to define local variables with type specifications Internal method for declare statements

(
        &self,
        declare_stmt: &DeclareStatement,
        context: &ExecutionContext,
    )

    /// Execute DECLARE statement to define local variables with type specifications
    /// Internal method for declare statements
    fn execute_declare_statement(
        &self,
        declare_stmt: &DeclareStatement,
        context: &ExecutionContext,
    ) -> Result<QueryResult, ExecutionError> {
        // For now, simulate variable declaration by storing in session state
        let mut declared_vars = Vec::new();

        for var_decl in &declare_stmt.variable_declarations {
            let initial_val = match &var_decl.initial_value {
                Some(expr) => {
                    // Evaluate the expression using the provided context so it can reference existing variables
                    self.evaluate_expression(expr, context)?
                }
                None => {
                    // Use type-appropriate default value
                    match var_decl.type_spec {
                        TypeSpec::Integer => Value::Number(0.0),
                        TypeSpec::String { .. } => Value::String("".to_string()),
                        TypeSpec::Boolean => Value::Boolean(false),
                        _ => Value::Null,
                    }
                }
            };

            // Store variable in session context
            self.set_session_parameter(&var_decl.variable_name, initial_val)?;

            declared_vars.push(format!(
                "{}: {} = {:?}",
                var_decl.variable_name,
                var_decl.type_spec,
                var_decl
                    .initial_value
                    .as_ref()
                    .map(|_| "initialized")
                    .unwrap_or("default")
            ));
        }

        // Return success result
        let rows_count = declared_vars.len();
        Ok(QueryResult {
            variables: vec!["variable_declaration".to_string()],
            rows: declared_vars
                .into_iter()
                .map(|var| {
                    let mut values = std::collections::HashMap::new();
                    values.insert("variable_declaration".to_string(), Value::String(var));
                    Row::from_values(values)
                })
                .collect(),
            rows_affected: rows_count,
            session_result: None,
            warnings: Vec::new(),

            execution_time_ms: 0,
        })