Function parse_ann_options

nodedb-sql/src/planner/select/entry_ann.rs:30–201

Parse named arguments of a vector distance function call into [`VectorAnnOptions`]. Positional args at positions 0 and 1 (field name and query vector) are ignored — this function only reads named args. Positional args at position ≥ 2 are rejected (old JSON-string form). Returns `VectorAnnOptions::default()` when no named options are present.

(func_args: &[ast::FunctionArg])

///
/// Returns `VectorAnnOptions::default()` when no named options are present.
pub fn parse_ann_options(func_args: &[ast::FunctionArg]) -> Result<VectorAnnOptions> {
    let mut opts = VectorAnnOptions::default();
    let mut seen = [false; 6]; // indexed by option slot

    let mut positional_idx: usize = 0;

    for arg in func_args {
        // Resolve the named arg to (key, value_expr, operator), or handle
        // positional/unsupported forms.
        let (key, value_expr, operator) = match arg {
            ast::FunctionArg::Unnamed(_) => {
                // First two positional args (field, query vector) are fine.
                if positional_idx >= 2 {
                    return Err(SqlError::Unsupported {
                        detail: "vector_distance: JSON-string options are no longer supported. \
                             Use named arguments instead: \
                             vector_distance(field, query, quantization => 'rabitq', ef_search => 100, oversample => 3)"
                            .into(),
                    });
                }
                positional_idx += 1;
                continue;
            }

            ast::FunctionArg::Named {
                name,
                arg,
                operator,
            } => {
                let key = name.value.to_ascii_lowercase();
                let expr = match arg {
                    ast::FunctionArgExpr::Expr(e) => e,
                    _ => {
                        return Err(SqlError::Unsupported {
                            detail: format!("ANN option '{key}': expected a value expression"),
                        });
                    }
                };
                (key, expr, operator)
            }

            // sqlparser may parse `ident => value` as ExprNamed when the name
            // is an identifier expression. Accept simple identifier names.
            ast::FunctionArg::ExprNamed {
                name: ast::Expr::Identifier(ident),
                arg,
                operator,
            } => {
                let key = ident.value.to_ascii_lowercase();
                let expr = match arg {
                    ast::FunctionArgExpr::Expr(e) => e,
                    _ => {
                        return Err(SqlError::Unsupported {
                            detail: format!("ANN option '{key}': expected a value expression"),
                        });
                    }
                };
                (key, expr, operator)