summa-core 2.0.0

Core async search engine library with WASM support
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

#![cfg(feature = "sync")]

use std::sync::Arc;

use summa_core::directories::MmapDirectory;
use summa_core::index::{Index, IndexConfig};
use summa_core::query::TermQuery;
use summa_core::{Document, SchemaBuilder};

#[tokio::test(flavor = "current_thread")]
async fn mmap_query_views_survive_reload_and_old_searcher_stays_valid() {
    let root = tempfile::tempdir().unwrap();
    let mut schema = SchemaBuilder::default();
    let field = schema.add_text_field("text", true, false);
    let index = Index::create(
        MmapDirectory::new(root.path()),
        schema.build(),
        IndexConfig {
            num_threads: 1,
            num_indexing_threads: 1,
            ..Default::default()
        },
    )
    .await
    .unwrap();
    let mut writer = index.writer();
    for _ in 0..5 {
        let mut doc = Document::new();
        doc.add_text(field, "common");
        writer.add_document(doc).unwrap();
    }
    writer.commit().await.unwrap();
    let reader = index.reader().await.unwrap();
    let old = reader.searcher().await.unwrap();
    let query = TermQuery::text(field, "common");
    assert_eq!(
        old.search_with_offset_and_count_sync(&query, 10, 0)
            .unwrap()
            .1,
        5
    );
    let old_segment = Arc::clone(&old.segment_readers()[0]);
    let mut old_bytes = Vec::new();
    old_segment
        .get_prefix_postings(field, b"comm")
        .await
        .unwrap()[0]
        .serialize(&mut old_bytes)
        .unwrap();
    for _ in 0..5 {
        let mut doc = Document::new();
        doc.add_text(field, "common other");
        writer.add_document(doc).unwrap();
    }
    writer.commit().await.unwrap();
    reader.reload().await.unwrap();
    let new = reader.searcher().await.unwrap();
    assert_eq!(
        new.search_with_offset_and_count(&query, 10, 0)
            .await
            .unwrap()
            .1,
        10
    );
    assert_eq!(
        old.search_with_offset_and_count(&query, 10, 0)
            .await
            .unwrap()
            .1,
        5
    );
    let reused = new
        .segment_readers()
        .iter()
        .find(|s| s.meta().id == old_segment.meta().id)
        .unwrap();
    assert!(Arc::ptr_eq(reused, &old_segment));
    let mut reused_bytes = Vec::new();
    reused.get_prefix_postings_sync(field, b"comm").unwrap()[0]
        .serialize(&mut reused_bytes)
        .unwrap();
    assert_eq!(old_bytes, reused_bytes);
    assert!(new.segment_readers().len() > old.segment_readers().len());
    writer.shutdown().await.unwrap();
}