Function leaf_ast_to_binary_expr

tiledb/oxidize/expr/src/query_condition.rs:105–205

(
    schema: &ArraySchema,
    ast: &ASTNode,
    op: Operator,
)

}

fn leaf_ast_to_binary_expr(
    schema: &ArraySchema,
    ast: &ASTNode,
    op: Operator,
) -> Result<Expr, Error> {
    let Some(field) = schema.field_cxx(ast.get_field_name()) else {
        return Err(
            UserError::UnknownField(ast.get_field_name().to_string_lossy().into_owned()).into(),
        );
    };

    fn apply<T>(field: &Field, ast: &ASTNode, operator: Operator) -> Result<Expr, Error>
    where
        T: FromBytes,
        <T as FromBytes>::Bytes: for<'a> TryFrom<&'a [u8]>,
        ScalarValue: From<T> + From<Option<T>>,
    {
        let column = Expr::Column(Column::from_name(
            field.name().map_err(UserError::FieldNameNotUtf8)?,
        ));

        let mut values = values_iter::<T>(field.datatype(), ast.get_data())?
            .map(ScalarValue::from)
            .peekable();

        let expect_datatype = tiledb_arrow::schema::field_arrow_datatype(field).map_err(|e| {
            InternalError::SchemaField(field.name_cxx().to_string_lossy().into_owned(), e)
        })?;

        let right = match field.cell_val_num() {
            CellValNum::Single => {
                let Some(r) = values.next() else {
                    return Err(UserError::CellValNumMismatch(field.cell_val_num(), 0).into());
                };
                if values.peek().is_some() {
                    return Err(UserError::CellValNumMismatch(
                        field.cell_val_num(),
                        1 + values.count(),
                    )
                    .into());
                } else {
                    r
                }
            }
            CellValNum::Fixed(nz) => {
                let values = if values.peek().is_none() {
                    aa::make_array(ArrayData::new_empty(&expect_datatype))
                } else {
                    // SAFETY: `values` produces a static type, so all will match.
                    // `values` is also non-empty per `peek`.
                    ScalarValue::iter_to_array(values).unwrap()
                };
                if values.len() != nz.get() as usize {
                    return Err(
                        UserError::CellValNumMismatch(field.cell_val_num(), values.len()).into(),
                    );
                }
                let Ok(fixed_size) = i32::try_from(nz.get()) else {