summavy 0.25.3

Search engine library
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use std::fmt;
use std::io::{self, Write};

pub use fastfield_codecs::Column;
use fastfield_codecs::{FastFieldCodecType, MonotonicallyMappableToU64, ALL_CODEC_TYPES};

use crate::directory::{CompositeWrite, WritePtr};
use crate::schema::Field;

/// `CompositeFastFieldSerializer` is in charge of serializing
/// fastfields on disk.
///
/// Fast fields have different encodings like bit-packing.
///
/// `FastFieldWriter`s are in charge of pushing the data to
/// the serializer.
/// The serializer expects to receive the following calls.
///
/// * `create_auto_detect_u64_fast_field(...)`
/// * `create_auto_detect_u64_fast_field(...)`
/// * ...
/// * `let bytes_fastfield = new_bytes_fast_field(...)`
/// * `bytes_fastfield.write_all(...)`
/// * `bytes_fastfield.write_all(...)`
/// * `bytes_fastfield.flush()`
/// * ...
/// * `close()`
pub struct CompositeFastFieldSerializer {
    composite_write: CompositeWrite<WritePtr>,
    codec_types: Vec<FastFieldCodecType>,
}

impl CompositeFastFieldSerializer {
    /// New fast field serializer with all codec types
    pub fn from_write(write: WritePtr) -> io::Result<CompositeFastFieldSerializer> {
        Self::from_write_with_codec(write, &ALL_CODEC_TYPES)
    }

    /// New fast field serializer with allowed codec types
    pub fn from_write_with_codec(
        write: WritePtr,
        codec_types: &[FastFieldCodecType],
    ) -> io::Result<CompositeFastFieldSerializer> {
        let composite_write = CompositeWrite::wrap(write);
        Ok(CompositeFastFieldSerializer {
            composite_write,
            codec_types: codec_types.to_vec(),
        })
    }

    /// Serialize data into a new u64 fast field. The best compression codec will be chosen
    /// automatically.
    pub fn create_auto_detect_u64_fast_field<T: MonotonicallyMappableToU64 + fmt::Debug>(
        &mut self,
        field: Field,
        fastfield_accessor: impl Column<T>,
    ) -> io::Result<()> {
        self.create_auto_detect_u64_fast_field_with_idx(field, fastfield_accessor, 0)
    }

    /// Serialize data into a new u64 fast field. The best compression codec will be chosen
    /// automatically.
    pub fn create_auto_detect_u64_fast_field_with_idx<
        T: MonotonicallyMappableToU64 + fmt::Debug,
    >(
        &mut self,
        field: Field,
        fastfield_accessor: impl Column<T>,
        idx: usize,
    ) -> io::Result<()> {
        let field_write = self.composite_write.for_field_with_idx(field, idx);
        fastfield_codecs::serialize(fastfield_accessor, field_write, &self.codec_types)?;
        Ok(())
    }

    /// Serialize data into a new u64 fast field. The best compression codec of the the provided
    /// will be chosen.
    pub fn create_auto_detect_u64_fast_field_with_idx_and_codecs<
        T: MonotonicallyMappableToU64 + fmt::Debug,
    >(
        &mut self,
        field: Field,
        fastfield_accessor: impl Column<T>,
        idx: usize,
        codec_types: &[FastFieldCodecType],
    ) -> io::Result<()> {
        let field_write = self.composite_write.for_field_with_idx(field, idx);
        fastfield_codecs::serialize(fastfield_accessor, field_write, codec_types)?;
        Ok(())
    }

    /// Serialize data into a new u128 fast field. The codec will be compact space compressor,
    /// which is optimized for scanning the fast field for a given range.
    pub fn create_u128_fast_field_with_idx<F: Fn() -> I, I: Iterator<Item = u128>>(
        &mut self,
        field: Field,
        iter_gen: F,
        num_vals: u32,
        idx: usize,
    ) -> io::Result<()> {
        let field_write = self.composite_write.for_field_with_idx(field, idx);
        fastfield_codecs::serialize_u128(iter_gen, num_vals, field_write)?;

        Ok(())
    }

    /// Start serializing a new [u8] fast field. Use the returned writer to write data into the
    /// bytes field. To associate the bytes with documents a seperate index must be created on
    /// index 0. See bytes/writer.rs::serialize for an example.
    ///
    /// The bytes will be stored as is, no compression will be applied.
    pub fn new_bytes_fast_field(&mut self, field: Field) -> impl Write + '_ {
        self.composite_write.for_field_with_idx(field, 1)
    }

    /// Closes the serializer
    ///
    /// After this call the data must be persistently saved on disk.
    pub fn close(self) -> io::Result<()> {
        self.composite_write.close()
    }
}