formualizer-eval 0.6.0

High-performance Arrow-backed Excel formula engine with dependency graph and incremental recalculation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use super::common::arrow_eval_config;
use crate::engine::Engine;
use crate::test_workbook::TestWorkbook;
use crate::traits::EvaluationContext;
use formualizer_common::LiteralValue;
use formualizer_parse::parser::ReferenceType;

#[test]
fn used_rows_for_columns_sees_sparse_overlay_for_whole_column_refs() {
    let mut cfg = arrow_eval_config();
    cfg.max_open_ended_rows = 10;

    let mut engine = Engine::new(TestWorkbook::new(), cfg);

    let sheet = "S";
    {
        let mut ab = engine.begin_bulk_ingest_arrow();
        ab.add_sheet(sheet, 1, 64);
        for _ in 0..64 {
            ab.append_row(sheet, &[LiteralValue::Empty]).unwrap();
        }
        ab.finish().unwrap();
    }

    let far_row: u32 = 1000;
    engine
        .set_cell_value(sheet, far_row, 1, LiteralValue::Int(1))
        .unwrap();

    // A:A
    let r = ReferenceType::range(Some(sheet.to_string()), None, Some(1), None, Some(1));

    let view = engine.resolve_range_view(&r, sheet).unwrap();
    let av = view;

    // Whole-column refs are anchored at row 1, but the end row should expand to the last used row
    // (even if the open-ended cap is smaller).
    assert_eq!(av.start_row(), 0);
    assert_eq!(av.end_row(), (far_row - 1) as usize);
    assert_eq!(
        av.get_cell((far_row - 1) as usize, 0),
        LiteralValue::Number(1.0)
    );
}

#[test]
fn used_cols_for_rows_sees_sparse_overlay_for_whole_row_refs() {
    let mut cfg = arrow_eval_config();
    cfg.max_open_ended_cols = 10;

    let mut engine = Engine::new(TestWorkbook::new(), cfg);

    let sheet = "S";
    let ncols: usize = 25;
    {
        let mut ab = engine.begin_bulk_ingest_arrow();
        ab.add_sheet(sheet, ncols, 64);
        let row = vec![LiteralValue::Empty; ncols];
        for _ in 0..64 {
            ab.append_row(sheet, &row).unwrap();
        }
        ab.finish().unwrap();
    }

    let far_row: u32 = 1000;
    let far_col: u32 = 20;
    engine
        .set_cell_value(sheet, far_row, far_col, LiteralValue::Int(1))
        .unwrap();

    // far_row:far_row
    let r = ReferenceType::range(
        Some(sheet.to_string()),
        Some(far_row),
        None,
        Some(far_row),
        None,
    );

    let view = engine.resolve_range_view(&r, sheet).unwrap();
    let av = view;

    // Whole-row refs are anchored at column A, but the end column should expand to the last used
    // column (even if the open-ended cap is smaller).
    assert_eq!(av.start_col(), 0);
    assert_eq!(av.end_col(), (far_col - 1) as usize);
    assert_eq!(
        av.get_cell(0, (far_col - 1) as usize),
        LiteralValue::Number(1.0)
    );
}