文档

pub trait Document: Send + Sync + 'static {
    /// The value of the field.
    type Value<'a>: Value<'a> + Clone
    where Self: 'a;

    /// The iterator over all of the fields and values within the doc.
    type FieldsValuesIter<'a>: Iterator<Item = (Field, Self::Value<'a>)>
    where Self: 'a;

    /// Get an iterator iterating over all fields and values in a document.
    fn iter_fields_and_values(&self) -> Self::FieldsValuesIter<'_>;
    // ...
}

pub enum ReferenceValue<'a, V>
where V: Value<'a> + ?Sized
{
    /// A null value.
    Leaf(ReferenceValueLeaf<'a>),
    /// A an array containing multiple values.
    Array(V::ArrayIter),
    /// A nested / dynamic object.
    Object(V::ObjectIter),
}

#[repr(C, packed)]
#[derive(Debug, Clone)]
/// A field value pair in the compact tantivy document
struct FieldValueAddr {
    pub field: u16,
    pub value_addr: ValueAddr,
}

#[derive(Debug, Clone)]
/// The default document in tantivy. It encodes data in a compact form.
pub struct CompactDoc {
    /// `node_data` is a vec of bytes, where each value is serialized into bytes and stored. It
    /// includes all the data of the document and also metadata like where the nodes are located
    /// in an object or array.
    ///
    /// Invariant: string values are only written from `&str`, so their bytes are valid UTF-8.
    /// `extract_str` relies on this. The field must not be exposed outside of the crate.
    pub(crate) node_data: Vec<u8>,
    /// The root (Field, Value) pairs
    field_values: Vec<FieldValueAddr>,
}

thread 'main' (6177819) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tantivy-0.27.0/src/schema/document/default_document.rs:164:18:
support only up to u16::MAX field ids: TryFromIntError(PosOverflow)

    pub(crate) fn serialize_doc<D>(&mut self, doc: &D) -> io::Result<()>
    where D: Document {
        let stored_field_values = || {
            doc.iter_fields_and_values()
                .filter(|(field, _)| self.schema.get_field_entry(*field).is_stored())
        };
        let num_field_values = stored_field_values().count();
        let mut actual_length = 0;

        VInt(num_field_values as u64).serialize(self.writer)?;
        for (field, value_access) in stored_field_values() {
            field.serialize(self.writer)?;

            let mut serializer = BinaryValueSerializer::new(self.writer);
            match value_access.as_value() {
                ReferenceValue::Leaf(ReferenceValueLeaf::PreTokStr(pre_tokenized_text)) => {
                    serializer.serialize_value(ReferenceValue::Leaf::<&'_ OwnedValue>(
                        ReferenceValueLeaf::Str(&pre_tokenized_text.text),
                    ))?;
                }
                _ => {
                    serializer.serialize_value(value_access.as_value())?;
                }
            }

            actual_length += 1;
        }
        // ...

  w.add_document(doc!(
    tag => "rust",
    title => "Old Man",
    body => "he was an old man",
    views => 7u64,
    score => 1.5f64,
    tag => "search",
    when => DateTime::from_timestamp_secs(1),
    meta => serde_json::json!({"a": 1})
  ))?;

doc 0 in store: 80 bytes
86 04 00 00 00 00 84 72 75 73 74 00 00 00 00 00 87 4f 6c 64 20 4d 61 6e 03 00 00 00 06 00 00 00 00 00 00 f8 bf 04 00 00 00 00 86 73 65 61 72 63 68 05 00 00 00 05 00 ca 9a 3b 00 00 00 00 06 00 00 00 0d 82 00 81 61 02 01 00 00 00 00 00 00 00

86                                    VInt 6：6 个值
04 00 00 00 | 00 | 84 72 75 73 74     tag   文本 长度 4  "rust"
00 00 00 00 | 00 | 87 4f 6c 64 20 4d 61 6e
                                      title 文本 长度 7  "Old Man"
03 00 00 00 | 06 | 00 00 00 00 00 00 f8 bf
                                      score f64 0xbff8000000000000（1.5 映射后）
04 00 00 00 | 00 | 86 73 65 61 72 63 68
                                      tag   文本 长度 6  "search"
05 00 00 00 | 05 | 00 ca 9a 3b 00 00 00 00
                                      when  日期 1_000_000_000 纳秒
06 00 00 00 | 0d | 82 | 00 81 61 | 02 01 00 00 00 00 00 00 00
                                      meta  对象 VInt 2（一对键值）
                                            键：文本 "a"；值：i64 1

    pub fn doc<D: DocumentDeserialize>(&self, doc_address: DocAddress) -> crate::Result<D> {
        let store_reader = &self.inner.store_readers[doc_address.segment_ord as usize];
        store_reader.get(doc_address.doc_id)
    }

to_json: {"meta":[{"a":1}],"score":[1.5],"tag":["rust","search"],"title":["Old Man"],"when":["1970-01-01T00:00:01Z"]}
get_first(body)  = None
get_first(views) = None
get_all(tag)     = [Some("rust"), Some("search")]
fast field views[0] = Some(7)

as BTreeMap<Field, OwnedValue>: {Field(0): Str("Old Man"), Field(3): F64(1.5), Field(4): Str("search"), Field(5): Date(1970-01-01T00:00:01Z), Field(6): Object([("a", I64(1))])}

        while let Some((field, value)) = deserializer.next_field()? {
            document.insert(field, value);
        }