make convert_to_fast_value_and_append_to_json_term pub

.github/workflows/coverage.yml

@@ -15,11 +15,11 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Install Rust
-        run: rustup toolchain install nightly-2024-04-10 --profile minimal --component llvm-tools-preview
+        run: rustup toolchain install nightly-2023-09-10 --profile minimal --component llvm-tools-preview
       - uses: Swatinem/rust-cache@v2
       - uses: taiki-e/install-action@cargo-llvm-cov
       - name: Generate code coverage
-        run: cargo +nightly-2024-04-10 llvm-cov --all-features --workspace --doctests --lcov --output-path lcov.info
+        run: cargo +nightly-2023-09-10 llvm-cov --all-features --workspace --doctests --lcov --output-path lcov.info
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v3
         continue-on-error: true

Cargo.toml

@@ -62,7 +62,6 @@ tokenizer-api = { version= "0.3", path="./tokenizer-api", package="tantivy-token
 sketches-ddsketch = { version = "0.2.1", features = ["use_serde"] }
 futures-util = { version = "0.3.28", optional = true }
 fnv = "1.0.7"
-mediumvec = "1.3.0"
 
 [target.'cfg(windows)'.dependencies]
 winapi = "0.3.9"
@@ -82,7 +81,6 @@ time = { version = "0.3.10", features = ["serde-well-known", "macros"] }
 postcard = { version = "1.0.4", features = [
   "use-std",
 ], default-features = false }
-peakmem-alloc = "0.3.0"
 
 [target.'cfg(not(windows))'.dev-dependencies]
 criterion = { version = "0.5", default-features = false }

examples/doc_mem.rs

@@ -1,335 +0,0 @@
-#![allow(unused_imports)]
-#![allow(dead_code)]
-use std::alloc::System;
-use std::env::args;
-use std::net::Ipv6Addr;
-
-use columnar::{MonotonicallyMappableToU128, MonotonicallyMappableToU64};
-use common::{BinarySerializable, CountingWriter, DateTime, FixedSize};
-use peakmem_alloc::*;
-use tantivy::schema::{Field, FieldValue, OwnedValue, FAST, INDEXED, STRING, TEXT};
-use tantivy::tokenizer::PreTokenizedString;
-use tantivy::{doc, TantivyDocument};
-
-const GH_LOGS: &str = include_str!("../benches/gh.json");
-const HDFS_LOGS: &str = include_str!("../benches/hdfs.json");
-
-#[global_allocator]
-static GLOBAL: &PeakMemAlloc<System> = &INSTRUMENTED_SYSTEM;
-
-fn main() {
-    dbg!(std::mem::size_of::<TantivyDocument>());
-    dbg!(std::mem::size_of::<DocContainerRef>());
-    dbg!(std::mem::size_of::<OwnedValue>());
-    dbg!(std::mem::size_of::<OwnedValueMedVec>());
-    dbg!(std::mem::size_of::<ValueContainerRef>());
-    dbg!(std::mem::size_of::<mediumvec::vec32::Vec32::<u8>>());
-
-    let filter = args().nth(1);
-    measure_fn(
-        test_hdfs::<TantivyDocument>,
-        "hdfs TantivyDocument",
-        &filter,
-    );
-    measure_fn(
-        test_hdfs::<TantivyDocumentMedVec>,
-        "hdfs TantivyDocumentMedVec",
-        &filter,
-    );
-    measure_fn(
-        test_hdfs::<DocContainerRef>,
-        "hdfs DocContainerRef",
-        &filter,
-    );
-    measure_fn(test_gh::<TantivyDocument>, "gh TantivyDocument", &filter);
-    measure_fn(
-        test_gh::<TantivyDocumentMedVec>,
-        "gh TantivyDocumentMedVec",
-        &filter,
-    );
-    measure_fn(test_gh::<DocContainerRef>, "gh DocContainerRef", &filter);
-}
-fn measure_fn<F: FnOnce()>(f: F, name: &str, filter: &Option<std::string::String>) {
-    if let Some(filter) = filter {
-        if !name.contains(filter) {
-            return;
-        }
-    }
-    GLOBAL.reset_peak_memory();
-    f();
-    println!("Peak Memory {} : {:#?}", GLOBAL.get_peak_memory(), name);
-}
-fn test_hdfs<T: From<TantivyDocument>>() {
-    let schema = {
-        let mut schema_builder = tantivy::schema::SchemaBuilder::new();
-        schema_builder.add_u64_field("timestamp", INDEXED);
-        schema_builder.add_text_field("body", TEXT);
-        schema_builder.add_text_field("severity", STRING);
-        schema_builder.build()
-    };
-    let mut docs: Vec<T> = Vec::with_capacity(HDFS_LOGS.lines().count());
-    for doc_json in HDFS_LOGS.lines() {
-        let doc = TantivyDocument::parse_json(&schema, doc_json)
-            .unwrap()
-            .into();
-        docs.push(doc);
-    }
-}
-
-fn test_gh<T: From<TantivyDocument>>() {
-    let schema = {
-        let mut schema_builder = tantivy::schema::SchemaBuilder::new();
-        schema_builder.add_json_field("json", FAST);
-        schema_builder.build()
-    };
-    let mut docs: Vec<T> = Vec::with_capacity(GH_LOGS.lines().count());
-    for doc_json in GH_LOGS.lines() {
-        let json_field = schema.get_field("json").unwrap();
-
-        let json_val: serde_json::Map<String, serde_json::Value> =
-            serde_json::from_str(doc_json).unwrap();
-        let doc = tantivy::doc!(json_field=>json_val).into();
-        docs.push(doc);
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-#[allow(dead_code)]
-pub struct TantivyDocumentMedVec {
-    field_values: mediumvec::Vec32<FieldValueMedVec>,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct FieldValueMedVec {
-    pub field: Field,
-    pub value: OwnedValueMedVec,
-}
-
-/// This is a owned variant of `Value`, that can be passed around without lifetimes.
-/// Represents the value of a any field.
-/// It is an enum over all over all of the possible field type.
-#[derive(Debug, Clone, PartialEq)]
-pub enum OwnedValueMedVec {
-    /// A null value.
-    Null,
-    /// The str type is used for any text information.
-    Str(mediumvec::vec32::Vec32<u8>),
-    /// Unsigned 64-bits Integer `u64`
-    U64(u64),
-    /// Signed 64-bits Integer `i64`
-    I64(i64),
-    /// 64-bits Float `f64`
-    F64(f64),
-    /// Bool value
-    Bool(bool),
-    /// Date/time with nanoseconds precision
-    Date(DateTime),
-    Array(mediumvec::vec32::Vec32<Self>),
-    /// Dynamic object value.
-    Object(mediumvec::vec32::Vec32<(String, Self)>),
-    /// IpV6 Address. Internally there is no IpV4, it needs to be converted to `Ipv6Addr`.
-    IpAddr(Ipv6Addr),
-    /// Pre-tokenized str type,
-    PreTokStr(Box<PreTokenizedString>),
-    /// Arbitrarily sized byte array
-    Bytes(mediumvec::vec32::Vec32<u8>),
-}
-
-impl From<TantivyDocument> for TantivyDocumentMedVec {
-    fn from(doc: TantivyDocument) -> Self {
-        let field_values = doc
-            .into_iter()
-            .map(|fv| FieldValueMedVec {
-                field: fv.field,
-                value: fv.value.into(),
-            })
-            .collect();
-        TantivyDocumentMedVec { field_values }
-    }
-}
-impl From<OwnedValue> for OwnedValueMedVec {
-    fn from(value: OwnedValue) -> Self {
-        match value {
-            OwnedValue::Null => OwnedValueMedVec::Null,
-            OwnedValue::Str(s) => {
-                let bytes = s.into_bytes();
-                let vec = mediumvec::vec32::Vec32::from_vec(bytes);
-                OwnedValueMedVec::Str(vec)
-            }
-            OwnedValue::U64(u) => OwnedValueMedVec::U64(u),
-            OwnedValue::I64(i) => OwnedValueMedVec::I64(i),
-            OwnedValue::F64(f) => OwnedValueMedVec::F64(f),
-            OwnedValue::Bool(b) => OwnedValueMedVec::Bool(b),
-            OwnedValue::Date(d) => OwnedValueMedVec::Date(d),
-            OwnedValue::Array(arr) => {
-                let arr = arr.into_iter().map(|v| v.into()).collect();
-                OwnedValueMedVec::Array(arr)
-            }
-            OwnedValue::Object(obj) => {
-                let obj = obj.into_iter().map(|(k, v)| (k, v.into())).collect();
-                OwnedValueMedVec::Object(obj)
-            }
-            OwnedValue::IpAddr(ip) => OwnedValueMedVec::IpAddr(ip),
-            _ => panic!("Unsupported value type {:?}", value),
-        }
-    }
-}
-
-#[repr(packed)]
-pub struct FieldValueContainerRef {
-    pub field: u16,
-    pub value: ValueContainerRef,
-}
-
-#[repr(packed)]
-struct DocContainerRef {
-    container: OwnedValueRefContainer,
-    field_values: mediumvec::Vec32<FieldValueContainerRef>,
-}
-
-#[derive(Default)]
-struct OwnedValueRefContainer {
-    nodes: mediumvec::Vec32<ValueContainerRef>,
-    node_data: mediumvec::Vec32<u8>,
-}
-impl OwnedValueRefContainer {
-    fn shrink_to_fit(&mut self) {
-        self.nodes.shrink_to_fit();
-        self.node_data.shrink_to_fit();
-    }
-}
-
-impl From<TantivyDocument> for DocContainerRef {
-    fn from(doc: TantivyDocument) -> Self {
-        let mut container = OwnedValueRefContainer::default();
-        let field_values = doc
-            .into_iter()
-            .map(|fv| FieldValueContainerRef {
-                field: fv.field.field_id().try_into().unwrap(),
-                value: container.add_value(fv.value),
-            })
-            .collect();
-        container.shrink_to_fit();
-        Self {
-            field_values,
-            container,
-        }
-    }
-}
-
-// References to positions in two array, one for the OwnedValueRef and the other for the encoded
-// bytes
-#[derive(Debug, Clone, PartialEq)]
-pub enum ValueContainerRef {
-    /// A null value.
-    Null,
-    /// The str type is used for any text information.
-    Str(u32),
-    /// Unsigned 64-bits Integer `u64`
-    U64(u32), // position of the serialized 8 bytes in the data array
-    /// Signed 64-bits Integer `i64`
-    I64(u32), // position of the serialized 8 bytes in the data array
-    /// 64-bits Float `f64`
-    F64(u32), // position of the serialized 8 bytes in the data array
-    /// Bool value
-    Bool(bool), // inlined bool
-    /// Date/time with nanoseconds precision
-    Date(u32), // position of the serialized 8 byte in the data array
-    Array(NodeAddress),
-    /// Dynamic object value.
-    Object(NodeAddress),
-    /// IpV6 Address. Internally there is no IpV4, it needs to be converted to `Ipv6Addr`.
-    IpAddr(u32), // position of the serialized 16 bytes in the data array
-    /// Arbitrarily sized byte array
-    Bytes(u32),
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct NodeAddress {
-    pos: u32,
-    num_nodes: u32,
-}
-
-impl OwnedValueRefContainer {
-    pub fn add_value(&mut self, value: OwnedValue) -> ValueContainerRef {
-        match value {
-            OwnedValue::Null => ValueContainerRef::Null,
-            OwnedValue::U64(num) => ValueContainerRef::U64(write_into(&mut self.node_data, num)),
-            OwnedValue::I64(num) => ValueContainerRef::I64(write_into(&mut self.node_data, num)),
-            OwnedValue::F64(num) => ValueContainerRef::F64(write_into(&mut self.node_data, num)),
-            OwnedValue::Bool(b) => ValueContainerRef::Bool(b),
-            OwnedValue::Date(date) => ValueContainerRef::Date(write_into(
-                &mut self.node_data,
-                date.into_timestamp_nanos(),
-            )),
-            OwnedValue::Str(bytes) => {
-                ValueContainerRef::Str(write_into(&mut self.node_data, bytes))
-            }
-            OwnedValue::Bytes(bytes) => {
-                ValueContainerRef::Bytes(write_into(&mut self.node_data, bytes))
-            }
-            OwnedValue::Array(elements) => {
-                let pos = self.nodes.len() as u32;
-                let len = elements.len() as u32;
-                for elem in elements {
-                    let ref_elem = self.add_value(elem);
-                    self.nodes.push(ref_elem);
-                }
-                ValueContainerRef::Array(NodeAddress {
-                    pos,
-                    num_nodes: len,
-                })
-            }
-            OwnedValue::Object(entries) => {
-                let pos = self.nodes.len() as u32;
-                let len = entries.len() as u32;
-                for (key, value) in entries {
-                    let ref_key = self.add_value(OwnedValue::Str(key));
-                    let ref_value = self.add_value(value);
-                    self.nodes.push(ref_key);
-                    self.nodes.push(ref_value);
-                }
-                ValueContainerRef::Object(NodeAddress {
-                    pos,
-                    num_nodes: len,
-                })
-            }
-            OwnedValue::IpAddr(num) => {
-                ValueContainerRef::IpAddr(write_into(&mut self.node_data, num.to_u128()))
-            }
-            OwnedValue::PreTokStr(_) => todo!(),
-            OwnedValue::Facet(_) => todo!(),
-        }
-    }
-}
-
-fn write_into<T: BinarySerializable>(data: &mut mediumvec::Vec32<u8>, value: T) -> u32 {
-    let pos = data.len() as u32;
-    data.as_vec(|vec| value.serialize(vec).unwrap());
-    pos
-}
-
-fn write_into_2<T: BinarySerializable>(data: &mut mediumvec::Vec32<u8>, value: T) -> NodeAddress {
-    let pos = data.len() as u32;
-    let mut len = 0;
-    data.as_vec(|vec| {
-        let mut wrt = CountingWriter::wrap(vec);
-        value.serialize(&mut wrt).unwrap();
-        len = wrt.written_bytes() as u32;
-    });
-    NodeAddress {
-        pos,
-        num_nodes: len,
-    }
-}
-
-// impl From<ContainerDocRef> for TantivyDocument {
-// fn from(doc: ContainerDocRef) -> Self {
-// let mut doc2 = TantivyDocument::new();
-// for fv in doc.field_values {
-// let field = Field::from_field_id(fv.field as u32);
-// let value = doc.container.get_value(fv.value);
-// doc2.add(FieldValue::new(field, value));
-//}
-// doc2
-//}

src/core/json_utils.rs

@@ -4,7 +4,8 @@ use rustc_hash::FxHashMap;
 
 use crate::postings::{IndexingContext, IndexingPosition, PostingsWriter};
 use crate::schema::document::{ReferenceValue, ReferenceValueLeaf, Value};
-use crate::schema::Type;
+use crate::schema::indexing_term::IndexingTerm;
+use crate::schema::{Field, Type};
 use crate::time::format_description::well_known::Rfc3339;
 use crate::time::{OffsetDateTime, UtcOffset};
 use crate::tokenizer::TextAnalyzer;
@@ -74,7 +75,7 @@ pub(crate) fn index_json_values<'a, V: Value<'a>>(
     json_visitors: impl Iterator<Item = crate::Result<V::ObjectIter>>,
     text_analyzer: &mut TextAnalyzer,
     expand_dots_enabled: bool,
-    term_buffer: &mut Term,
+    term_buffer: &mut IndexingTerm,
     postings_writer: &mut dyn PostingsWriter,
     json_path_writer: &mut JsonPathWriter,
     ctx: &mut IndexingContext,
@@ -103,7 +104,7 @@ fn index_json_object<'a, V: Value<'a>>(
     doc: DocId,
     json_visitor: V::ObjectIter,
     text_analyzer: &mut TextAnalyzer,
-    term_buffer: &mut Term,
+    term_buffer: &mut IndexingTerm,
     json_path_writer: &mut JsonPathWriter,
     postings_writer: &mut dyn PostingsWriter,
     ctx: &mut IndexingContext,
@@ -130,19 +131,16 @@ fn index_json_value<'a, V: Value<'a>>(
     doc: DocId,
     json_value: V,
     text_analyzer: &mut TextAnalyzer,
-    term_buffer: &mut Term,
+    term_buffer: &mut IndexingTerm,
     json_path_writer: &mut JsonPathWriter,
     postings_writer: &mut dyn PostingsWriter,
     ctx: &mut IndexingContext,
     positions_per_path: &mut IndexingPositionsPerPath,
 ) {
-    let set_path_id = |term_buffer: &mut Term, unordered_id: u32| {
+    let set_path_id = |term_buffer: &mut IndexingTerm, unordered_id: u32| {
         term_buffer.truncate_value_bytes(0);
         term_buffer.append_bytes(&unordered_id.to_be_bytes());
     };
-    let set_type = |term_buffer: &mut Term, typ: Type| {
-        term_buffer.append_bytes(&[typ.to_code()]);
-    };
 
     match json_value.as_value() {
         ReferenceValue::Leaf(leaf) => match leaf {
@@ -155,7 +153,7 @@ fn index_json_value<'a, V: Value<'a>>(
 
                 // TODO: make sure the chain position works out.
                 set_path_id(term_buffer, unordered_id);
-                set_type(term_buffer, Type::Str);
+                term_buffer.append_bytes(&[Type::Str.to_code()]);
                 let indexing_position = positions_per_path.get_position_from_id(unordered_id);
                 postings_writer.index_text(
                     doc,
@@ -211,18 +209,16 @@ fn index_json_value<'a, V: Value<'a>>(
                 postings_writer.subscribe(doc, 0u32, term_buffer, ctx);
             }
             ReferenceValueLeaf::PreTokStr(_) => {
-                unimplemented!(
-                    "Pre-tokenized string support in dynamic fields is not yet implemented"
-                )
+                unimplemented!("Pre-tokenized string support in JSON fields is not yet implemented")
             }
             ReferenceValueLeaf::Bytes(_) => {
-                unimplemented!("Bytes support in dynamic fields is not yet implemented")
+                unimplemented!("Bytes support in JSON fields is not yet implemented")
             }
             ReferenceValueLeaf::Facet(_) => {
-                unimplemented!("Facet support in dynamic fields is not yet implemented")
+                unimplemented!("Facet support in JSON fields is not yet implemented")
             }
             ReferenceValueLeaf::IpAddr(_) => {
-                unimplemented!("IP address support in dynamic fields is not yet implemented")
+                unimplemented!("IP address support in JSON fields is not yet implemented")
             }
         },
         ReferenceValue::Array(elements) => {
@@ -257,14 +253,12 @@ fn index_json_value<'a, V: Value<'a>>(
 /// Tries to infer a JSON type from a string and append it to the term.
 ///
 /// The term must be json + JSON path.
-pub(crate) fn convert_to_fast_value_and_append_to_json_term(
-    mut term: Term,
-    phrase: &str,
-) -> Option<Term> {
+pub fn convert_to_fast_value_and_append_to_json_term(mut term: Term, phrase: &str) -> Option<Term> {
     assert_eq!(
         term.value()
-            .as_json_value_bytes()
+            .as_json()
             .expect("expecting a Term with a json type and json path")
+            .1
             .as_serialized()
             .len(),
         0,
@@ -349,24 +343,44 @@ pub(crate) fn encode_column_name(
     path.into()
 }
 
+pub fn term_from_json_paths<'a>(
+    json_field: Field,
+    paths: impl Iterator<Item = &'a str>,
+    expand_dots_enabled: bool,
+) -> Term {
+    let mut json_path = JsonPathWriter::with_expand_dots(expand_dots_enabled);
+    for path in paths {
+        json_path.push(path);
+    }
+    json_path.set_end();
+    let mut term = Term::with_type_and_field(Type::Json, json_field);
+
+    term.append_bytes(json_path.as_str().as_bytes());
+    term
+}
+
 #[cfg(test)]
 mod tests {
     use super::split_json_path;
+    use crate::json_utils::term_from_json_paths;
     use crate::schema::Field;
-    use crate::Term;
 
     #[test]
     fn test_json_writer() {
         let field = Field::from_field_id(1);
 
-        let mut term = Term::from_field_json_path(field, "attributes.color", false);
+        let mut term = term_from_json_paths(field, ["attributes", "color"].into_iter(), false);
         term.append_type_and_str("red");
         assert_eq!(
             format!("{:?}", term),
             "Term(field=1, type=Json, path=attributes.color, type=Str, \"red\")"
         );
 
-        let mut term = Term::from_field_json_path(field, "attributes.dimensions.width", false);
+        let mut term = term_from_json_paths(
+            field,
+            ["attributes", "dimensions", "width"].into_iter(),
+            false,
+        );
         term.append_type_and_fast_value(400i64);
         assert_eq!(
             format!("{:?}", term),
@@ -377,7 +391,7 @@ mod tests {
     #[test]
     fn test_string_term() {
         let field = Field::from_field_id(1);
-        let mut term = Term::from_field_json_path(field, "color", false);
+        let mut term = term_from_json_paths(field, ["color"].into_iter(), false);
         term.append_type_and_str("red");
 
         assert_eq!(term.serialized_term(), b"\x00\x00\x00\x01jcolor\x00sred")
@@ -386,46 +400,46 @@ mod tests {
     #[test]
     fn test_i64_term() {
         let field = Field::from_field_id(1);
-        let mut term = Term::from_field_json_path(field, "color", false);
+        let mut term = term_from_json_paths(field, ["color"].into_iter(), false);
         term.append_type_and_fast_value(-4i64);
 
         assert_eq!(
-            term.serialized_term(),
-            b"\x00\x00\x00\x01jcolor\x00i\x7f\xff\xff\xff\xff\xff\xff\xfc"
+            term.value().as_serialized(),
+            b"jcolor\x00i\x7f\xff\xff\xff\xff\xff\xff\xfc"
         )
     }
 
     #[test]
     fn test_u64_term() {
         let field = Field::from_field_id(1);
-        let mut term = Term::from_field_json_path(field, "color", false);
+        let mut term = term_from_json_paths(field, ["color"].into_iter(), false);
         term.append_type_and_fast_value(4u64);
 
         assert_eq!(
-            term.serialized_term(),
-            b"\x00\x00\x00\x01jcolor\x00u\x00\x00\x00\x00\x00\x00\x00\x04"
+            term.value().as_serialized(),
+            b"jcolor\x00u\x00\x00\x00\x00\x00\x00\x00\x04"
         )
     }
 
     #[test]
     fn test_f64_term() {
         let field = Field::from_field_id(1);
-        let mut term = Term::from_field_json_path(field, "color", false);
+        let mut term = term_from_json_paths(field, ["color"].into_iter(), false);
         term.append_type_and_fast_value(4.0f64);
         assert_eq!(
-            term.serialized_term(),
-            b"\x00\x00\x00\x01jcolor\x00f\xc0\x10\x00\x00\x00\x00\x00\x00"
+            term.value().as_serialized(),
+            b"jcolor\x00f\xc0\x10\x00\x00\x00\x00\x00\x00"
         )
     }
 
     #[test]
     fn test_bool_term() {
         let field = Field::from_field_id(1);
-        let mut term = Term::from_field_json_path(field, "color", false);
+        let mut term = term_from_json_paths(field, ["color"].into_iter(), false);
         term.append_type_and_fast_value(true);
         assert_eq!(
-            term.serialized_term(),
-            b"\x00\x00\x00\x01jcolor\x00o\x00\x00\x00\x00\x00\x00\x00\x01"
+            term.value().as_serialized(),
+            b"jcolor\x00o\x00\x00\x00\x00\x00\x00\x00\x01"
         )
     }
 

src/core/tests.rs

@@ -1,6 +1,7 @@
 use crate::collector::Count;
 use crate::directory::{RamDirectory, WatchCallback};
 use crate::indexer::{LogMergePolicy, NoMergePolicy};
+use crate::json_utils::term_from_json_paths;
 use crate::query::TermQuery;
 use crate::schema::{Field, IndexRecordOption, Schema, INDEXED, STRING, TEXT};
 use crate::tokenizer::TokenizerManager;
@@ -416,7 +417,7 @@ fn test_non_text_json_term_freq() {
     let segment_reader = searcher.segment_reader(0u32);
     let inv_idx = segment_reader.inverted_index(field).unwrap();
 
-    let mut term = Term::from_field_json_path(field, "tenant_id", false);
+    let mut term = term_from_json_paths(field, ["tenant_id"].iter().cloned(), false);
     term.append_type_and_fast_value(75u64);
 
     let postings = inv_idx
@@ -450,7 +451,7 @@ fn test_non_text_json_term_freq_bitpacked() {
     let segment_reader = searcher.segment_reader(0u32);
     let inv_idx = segment_reader.inverted_index(field).unwrap();
 
-    let mut term = Term::from_field_json_path(field, "tenant_id", false);
+    let mut term = term_from_json_paths(field, ["tenant_id"].iter().cloned(), false);
     term.append_type_and_fast_value(75u64);
 
     let mut postings = inv_idx

src/functional_test.rs

@@ -6,7 +6,6 @@ use rand::{thread_rng, Rng};
 
 use crate::indexer::index_writer::MEMORY_BUDGET_NUM_BYTES_MIN;
 use crate::schema::*;
-#[allow(deprecated)]
 use crate::{doc, schema, Index, IndexSettings, IndexSortByField, IndexWriter, Order, Searcher};
 
 fn check_index_content(searcher: &Searcher, vals: &[u64]) -> crate::Result<()> {

src/indexer/segment_writer.rs

@@ -1,4 +1,3 @@
-use columnar::MonotonicallyMappableToU64;
 use common::JsonPathWriter;
 use itertools::Itertools;
 use tokenizer_api::BoxTokenStream;
@@ -15,7 +14,8 @@ use crate::postings::{
     PerFieldPostingsWriter, PostingsWriter,
 };
 use crate::schema::document::{Document, ReferenceValue, Value};
-use crate::schema::{FieldEntry, FieldType, Schema, Term, DATE_TIME_PRECISION_INDEXED};
+use crate::schema::indexing_term::IndexingTerm;
+use crate::schema::{FieldEntry, FieldType, Schema};
 use crate::store::{StoreReader, StoreWriter};
 use crate::tokenizer::{FacetTokenizer, PreTokenizedStream, TextAnalyzer, Tokenizer};
 use crate::{DocId, Opstamp, SegmentComponent, TantivyError};
@@ -70,7 +70,7 @@ pub struct SegmentWriter {
     pub(crate) json_path_writer: JsonPathWriter,
     pub(crate) doc_opstamps: Vec<Opstamp>,
     per_field_text_analyzers: Vec<TextAnalyzer>,
-    term_buffer: Term,
+    term_buffer: IndexingTerm,
     schema: Schema,
 }
 
@@ -126,7 +126,7 @@ impl SegmentWriter {
             )?,
             doc_opstamps: Vec::with_capacity(1_000),
             per_field_text_analyzers,
-            term_buffer: Term::with_capacity(16),
+            term_buffer: IndexingTerm::new(),
             schema,
         })
     }
@@ -195,7 +195,7 @@ impl SegmentWriter {
             let (term_buffer, ctx) = (&mut self.term_buffer, &mut self.ctx);
             let postings_writer: &mut dyn PostingsWriter =
                 self.per_field_postings_writers.get_for_field_mut(field);
-            term_buffer.clear_with_field_and_type(field_entry.field_type().value_type(), field);
+            term_buffer.clear_with_field(field);
 
             match field_entry.field_type() {
                 FieldType::Facet(_) => {
@@ -271,8 +271,7 @@ impl SegmentWriter {
 
                         num_vals += 1;
                         let date_val = value.as_datetime().ok_or_else(make_schema_error)?;
-                        term_buffer
-                            .set_u64(date_val.truncate(DATE_TIME_PRECISION_INDEXED).to_u64());
+                        term_buffer.set_date(date_val);
                         postings_writer.subscribe(doc_id, 0u32, term_buffer, ctx);
                     }
                     if field_entry.has_fieldnorms() {
@@ -332,7 +331,7 @@ impl SegmentWriter {
 
                         num_vals += 1;
                         let bytes = value.as_bytes().ok_or_else(make_schema_error)?;
-                        term_buffer.set_bytes(bytes);
+                        term_buffer.set_value_bytes(bytes);
                         postings_writer.subscribe(doc_id, 0u32, term_buffer, ctx);
                     }
                     if field_entry.has_fieldnorms() {
@@ -498,6 +497,7 @@ mod tests {
     use crate::collector::{Count, TopDocs};
     use crate::directory::RamDirectory;
     use crate::fastfield::FastValue;
+    use crate::json_utils::term_from_json_paths;
     use crate::postings::TermInfo;
     use crate::query::{PhraseQuery, QueryParser};
     use crate::schema::document::Value;
@@ -646,8 +646,9 @@ mod tests {
 
         let mut term_stream = term_dict.stream().unwrap();
 
-        let term_from_path =
-            |path: &str| -> Term { Term::from_field_json_path(json_field, path, false) };
+        let term_from_path = |paths: &[&str]| -> Term {
+            term_from_json_paths(json_field, paths.iter().cloned(), false)
+        };
 
         fn set_fast_val<T: FastValue>(val: T, mut term: Term) -> Term {
             term.append_type_and_fast_value(val);
@@ -658,14 +659,15 @@ mod tests {
             term
         }
 
-        let term = term_from_path("bool");
+        let term = term_from_path(&["bool"]);
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
             set_fast_val(true, term).serialized_value_bytes()
         );
 
-        let term = term_from_path("complexobject.field\\.with\\.dot");
+        let term = term_from_path(&["complexobject", "field.with.dot"]);
+
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
@@ -673,7 +675,7 @@ mod tests {
         );
 
         // Date
-        let term = term_from_path("date");
+        let term = term_from_path(&["date"]);
 
         assert!(term_stream.advance());
         assert_eq!(
@@ -688,7 +690,7 @@ mod tests {
         );
 
         // Float
-        let term = term_from_path("float");
+        let term = term_from_path(&["float"]);
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
@@ -696,21 +698,21 @@ mod tests {
         );
 
         // Number In Array
-        let term = term_from_path("my_arr");
+        let term = term_from_path(&["my_arr"]);
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
             set_fast_val(2i64, term).serialized_value_bytes()
         );
 
-        let term = term_from_path("my_arr");
+        let term = term_from_path(&["my_arr"]);
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
             set_fast_val(3i64, term).serialized_value_bytes()
         );
 
-        let term = term_from_path("my_arr");
+        let term = term_from_path(&["my_arr"]);
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
@@ -718,13 +720,13 @@ mod tests {
         );
 
         // El in Array
-        let term = term_from_path("my_arr.my_key");
+        let term = term_from_path(&["my_arr", "my_key"]);
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
             set_str("tokens", term).serialized_value_bytes()
         );
-        let term = term_from_path("my_arr.my_key");
+        let term = term_from_path(&["my_arr", "my_key"]);
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
@@ -732,21 +734,21 @@ mod tests {
         );
 
         // Signed
-        let term = term_from_path("signed");
+        let term = term_from_path(&["signed"]);
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
             set_fast_val(-2i64, term).serialized_value_bytes()
         );
 
-        let term = term_from_path("toto");
+        let term = term_from_path(&["toto"]);
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
             set_str("titi", term).serialized_value_bytes()
         );
         // Unsigned
-        let term = term_from_path("unsigned");
+        let term = term_from_path(&["unsigned"]);
         assert!(term_stream.advance());
         assert_eq!(
             term_stream.key(),
@@ -773,7 +775,7 @@ mod tests {
         let searcher = reader.searcher();
         let segment_reader = searcher.segment_reader(0u32);
         let inv_index = segment_reader.inverted_index(json_field).unwrap();
-        let mut term = Term::from_field_json_path(json_field, "mykey", false);
+        let mut term = term_from_json_paths(json_field, ["mykey"].into_iter(), false);
         term.append_type_and_str("token");
         let term_info = inv_index.get_term_info(&term).unwrap().unwrap();
         assert_eq!(
@@ -812,7 +814,7 @@ mod tests {
         let searcher = reader.searcher();
         let segment_reader = searcher.segment_reader(0u32);
         let inv_index = segment_reader.inverted_index(json_field).unwrap();
-        let mut term = Term::from_field_json_path(json_field, "mykey", false);
+        let mut term = term_from_json_paths(json_field, ["mykey"].into_iter(), false);
         term.append_type_and_str("two tokens");
         let term_info = inv_index.get_term_info(&term).unwrap().unwrap();
         assert_eq!(
@@ -853,7 +855,7 @@ mod tests {
         let reader = index.reader().unwrap();
         let searcher = reader.searcher();
 
-        let term = Term::from_field_json_path(json_field, "mykey.field", false);
+        let term = term_from_json_paths(json_field, ["mykey", "field"].into_iter(), false);
 
         let mut hello_term = term.clone();
         hello_term.append_type_and_str("hello");

src/postings/json_postings_writer.rs

@@ -8,9 +8,10 @@ use crate::indexer::path_to_unordered_id::OrderedPathId;
 use crate::postings::postings_writer::SpecializedPostingsWriter;
 use crate::postings::recorder::{BufferLender, DocIdRecorder, Recorder};
 use crate::postings::{FieldSerializer, IndexingContext, IndexingPosition, PostingsWriter};
-use crate::schema::{Field, Type};
+use crate::schema::indexing_term::IndexingTerm;
+use crate::schema::{Field, Type, ValueBytes};
 use crate::tokenizer::TokenStream;
-use crate::{DocId, Term};
+use crate::DocId;
 
 /// The `JsonPostingsWriter` is odd in that it relies on a hidden contract:
 ///
@@ -34,7 +35,7 @@ impl<Rec: Recorder> PostingsWriter for JsonPostingsWriter<Rec> {
         &mut self,
         doc: crate::DocId,
         pos: u32,
-        term: &crate::Term,
+        term: &IndexingTerm,
         ctx: &mut IndexingContext,
     ) {
         self.non_str_posting_writer.subscribe(doc, pos, term, ctx);
@@ -44,7 +45,7 @@ impl<Rec: Recorder> PostingsWriter for JsonPostingsWriter<Rec> {
         &mut self,
         doc_id: DocId,
         token_stream: &mut dyn TokenStream,
-        term_buffer: &mut Term,
+        term_buffer: &mut IndexingTerm,
         ctx: &mut IndexingContext,
         indexing_position: &mut IndexingPosition,
     ) {
@@ -66,42 +67,40 @@ impl<Rec: Recorder> PostingsWriter for JsonPostingsWriter<Rec> {
         ctx: &IndexingContext,
         serializer: &mut FieldSerializer,
     ) -> io::Result<()> {
-        let mut term_buffer = Term::with_capacity(48);
+        let mut term_buffer = JsonTermSerializer(Vec::with_capacity(48));
         let mut buffer_lender = BufferLender::default();
-        term_buffer.clear_with_field_and_type(Type::Json, Field::from_field_id(0));
         let mut prev_term_id = u32::MAX;
         let mut term_path_len = 0; // this will be set in the first iteration
         for (_field, path_id, term, addr) in term_addrs {
             if prev_term_id != path_id.path_id() {
-                term_buffer.truncate_value_bytes(0);
+                term_buffer.clear();
                 term_buffer.append_path(ordered_id_to_path[path_id.path_id() as usize].as_bytes());
                 term_buffer.append_bytes(&[JSON_END_OF_PATH]);
-                term_path_len = term_buffer.len_bytes();
+                term_path_len = term_buffer.len();
                 prev_term_id = path_id.path_id();
             }
-            term_buffer.truncate_value_bytes(term_path_len);
+            term_buffer.truncate(term_path_len);
             term_buffer.append_bytes(term);
-            if let Some(json_value) = term_buffer.value().as_json_value_bytes() {
-                let typ = json_value.typ();
-                if typ == Type::Str {
-                    SpecializedPostingsWriter::<Rec>::serialize_one_term(
-                        term_buffer.serialized_value_bytes(),
-                        *addr,
-                        doc_id_map,
-                        &mut buffer_lender,
-                        ctx,
-                        serializer,
-                    )?;
-                } else {
-                    SpecializedPostingsWriter::<DocIdRecorder>::serialize_one_term(
-                        term_buffer.serialized_value_bytes(),
-                        *addr,
-                        doc_id_map,
-                        &mut buffer_lender,
-                        ctx,
-                        serializer,
-                    )?;
-                }
+            let json_value = ValueBytes::wrap(term);
+            let typ = json_value.typ();
+            if typ == Type::Str {
+                SpecializedPostingsWriter::<Rec>::serialize_one_term(
+                    term_buffer.as_bytes(),
+                    *addr,
+                    doc_id_map,
+                    &mut buffer_lender,
+                    ctx,
+                    serializer,
+                )?;
+            } else {
+                SpecializedPostingsWriter::<DocIdRecorder>::serialize_one_term(
+                    term_buffer.as_bytes(),
+                    *addr,
+                    doc_id_map,
+                    &mut buffer_lender,
+                    ctx,
+                    serializer,
+                )?;
             }
         }
         Ok(())
@@ -111,3 +110,40 @@ impl<Rec: Recorder> PostingsWriter for JsonPostingsWriter<Rec> {
         self.str_posting_writer.total_num_tokens() + self.non_str_posting_writer.total_num_tokens()
     }
 }
+
+struct JsonTermSerializer(Vec<u8>);
+impl JsonTermSerializer {
+    #[inline]
+    pub fn append_path(&mut self, bytes: &[u8]) {
+        if bytes.contains(&0u8) {
+            self.0
+                .extend(bytes.iter().map(|&b| if b == 0 { b'0' } else { b }));
+        } else {
+            self.0.extend_from_slice(bytes);
+        }
+    }
+
+    /// Appends value bytes to the Term.
+    ///
+    /// This function returns the segment that has just been added.
+    #[inline]
+    pub fn append_bytes(&mut self, bytes: &[u8]) -> &mut [u8] {
+        let len_before = self.0.len();
+        self.0.extend_from_slice(bytes);
+        &mut self.0[len_before..]
+    }
+
+    fn clear(&mut self) {
+        self.0.clear();
+    }
+    fn truncate(&mut self, len: usize) {
+        self.0.truncate(len);
+    }
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+}

src/postings/postings_writer.rs

@@ -11,7 +11,8 @@ use crate::postings::recorder::{BufferLender, Recorder};
 use crate::postings::{
     FieldSerializer, IndexingContext, InvertedIndexSerializer, PerFieldPostingsWriter,
 };
-use crate::schema::{Field, Schema, Term, Type};
+use crate::schema::indexing_term::{get_field_from_indexing_term, IndexingTerm};
+use crate::schema::{Field, Schema, Type};
 use crate::tokenizer::{Token, TokenStream, MAX_TOKEN_LEN};
 use crate::DocId;
 
@@ -60,14 +61,14 @@ pub(crate) fn serialize_postings(
     let mut term_offsets: Vec<(Field, OrderedPathId, &[u8], Addr)> =
         Vec::with_capacity(ctx.term_index.len());
     term_offsets.extend(ctx.term_index.iter().map(|(key, addr)| {
-        let field = Term::wrap(key).field();
+        let field = get_field_from_indexing_term(key);
         if schema.get_field_entry(field).field_type().value_type() == Type::Json {
-            let byte_range_path = 5..5 + 4;
+            let byte_range_path = 4..4 + 4;
             let unordered_id = u32::from_be_bytes(key[byte_range_path.clone()].try_into().unwrap());
             let path_id = unordered_id_to_ordered_id[unordered_id as usize];
             (field, path_id, &key[byte_range_path.end..], addr)
         } else {
-            (field, 0.into(), &key[5..], addr)
+            (field, 0.into(), &key[4..], addr)
         }
     }));
     // Sort by field, path, and term
@@ -114,7 +115,7 @@ pub(crate) trait PostingsWriter: Send + Sync {
     /// * term - the term
     /// * ctx - Contains a term hashmap and a memory arena to store all necessary posting list
     ///   information.
-    fn subscribe(&mut self, doc: DocId, pos: u32, term: &Term, ctx: &mut IndexingContext);
+    fn subscribe(&mut self, doc: DocId, pos: u32, term: &IndexingTerm, ctx: &mut IndexingContext);
 
     /// Serializes the postings on disk.
     /// The actual serialization format is handled by the `PostingsSerializer`.
@@ -132,7 +133,7 @@ pub(crate) trait PostingsWriter: Send + Sync {
         &mut self,
         doc_id: DocId,
         token_stream: &mut dyn TokenStream,
-        term_buffer: &mut Term,
+        term_buffer: &mut IndexingTerm,
         ctx: &mut IndexingContext,
         indexing_position: &mut IndexingPosition,
     ) {
@@ -203,26 +204,35 @@ impl<Rec: Recorder> SpecializedPostingsWriter<Rec> {
 
 impl<Rec: Recorder> PostingsWriter for SpecializedPostingsWriter<Rec> {
     #[inline]
-    fn subscribe(&mut self, doc: DocId, position: u32, term: &Term, ctx: &mut IndexingContext) {
-        debug_assert!(term.serialized_term().len() >= 4);
+    fn subscribe(
+        &mut self,
+        doc: DocId,
+        position: u32,
+        term: &IndexingTerm,
+        ctx: &mut IndexingContext,
+    ) {
+        debug_assert!(term.serialized_for_hashmap().len() >= 4);
         self.total_num_tokens += 1;
         let (term_index, arena) = (&mut ctx.term_index, &mut ctx.arena);
-        term_index.mutate_or_create(term.serialized_term(), |opt_recorder: Option<Rec>| {
-            if let Some(mut recorder) = opt_recorder {
-                let current_doc = recorder.current_doc();
-                if current_doc != doc {
-                    recorder.close_doc(arena);
+        term_index.mutate_or_create(
+            term.serialized_for_hashmap(),
+            |opt_recorder: Option<Rec>| {
+                if let Some(mut recorder) = opt_recorder {
+                    let current_doc = recorder.current_doc();
+                    if current_doc != doc {
+                        recorder.close_doc(arena);
+                        recorder.new_doc(doc, arena);
+                    }
+                    recorder.record_position(position, arena);
+                    recorder
+                } else {
+                    let mut recorder = Rec::default();
                     recorder.new_doc(doc, arena);
+                    recorder.record_position(position, arena);
+                    recorder
                 }
-                recorder.record_position(position, arena);
-                recorder
-            } else {
-                let mut recorder = Rec::default();
-                recorder.new_doc(doc, arena);
-                recorder.record_position(position, arena);
-                recorder
-            }
-        });
+            },
+        );
     }
 
     fn serialize(

src/query/fuzzy_query.rs

@@ -3,7 +3,7 @@ use once_cell::sync::OnceCell;
 use tantivy_fst::Automaton;
 
 use crate::query::{AutomatonWeight, EnableScoring, Query, Weight};
-use crate::schema::{Term, Type};
+use crate::schema::Term;
 use crate::TantivyError::InvalidArgument;
 
 pub(crate) struct DfaWrapper(pub DFA);
@@ -133,40 +133,33 @@ impl FuzzyTermQuery {
 
         let term_value = self.term.value();
 
-        let term_text = if term_value.typ() == Type::Json {
-            if let Some(json_path_type) = term_value.json_path_type() {
-                if json_path_type != Type::Str {
-                    return Err(InvalidArgument(format!(
-                        "The fuzzy term query requires a string path type for a json term. Found \
-                         {:?}",
-                        json_path_type
-                    )));
-                }
+        let get_automaton = |term_text: &str| {
+            if self.prefix {
+                automaton_builder.build_prefix_dfa(term_text)
+            } else {
+                automaton_builder.build_dfa(term_text)
             }
-
-            std::str::from_utf8(self.term.serialized_value_bytes()).map_err(|_| {
-                InvalidArgument(
-                    "Failed to convert json term value bytes to utf8 string.".to_string(),
-                )
-            })?
-        } else {
-            term_value.as_str().ok_or_else(|| {
-                InvalidArgument("The fuzzy term query requires a string term.".to_string())
-            })?
-        };
-        let automaton = if self.prefix {
-            automaton_builder.build_prefix_dfa(term_text)
-        } else {
-            automaton_builder.build_dfa(term_text)
         };
 
-        if let Some((json_path_bytes, _)) = term_value.as_json() {
+        if let Some((json_path_bytes, _term_value)) = term_value.as_json() {
+            let term_text =
+                std::str::from_utf8(self.term.serialized_value_bytes()).map_err(|_| {
+                    InvalidArgument(
+                        "Failed to convert json term value bytes to utf8 string.".to_string(),
+                    )
+                })?;
+
+            let automaton = get_automaton(term_text);
             Ok(AutomatonWeight::new_for_json_path(
                 self.term.field(),
                 DfaWrapper(automaton),
                 json_path_bytes,
             ))
         } else {
+            let term_text = term_value.as_str().ok_or_else(|| {
+                InvalidArgument("The fuzzy term query requires a string term.".to_string())
+            })?;
+            let automaton = get_automaton(term_text);
             Ok(AutomatonWeight::new(
                 self.term.field(),
                 DfaWrapper(automaton),

src/query/phrase_prefix_query/phrase_prefix_query.rs

@@ -137,7 +137,7 @@ impl Query for PhrasePrefixQuery {
             // There are no prefix. Let's just match the suffix.
             let end_term =
                 if let Some(end_value) = prefix_end(self.prefix.1.serialized_value_bytes()) {
-                    let mut end_term = Term::with_capacity(end_value.len());
+                    let mut end_term = Term::new();
                     end_term.set_field_and_type(self.field, self.prefix.1.typ());
                     end_term.append_bytes(&end_value);
                     Bound::Excluded(end_term)

src/query/query_parser/query_parser.rs

@@ -11,7 +11,9 @@ use rustc_hash::FxHashMap;
 
 use super::logical_ast::*;
 use crate::index::Index;
-use crate::json_utils::convert_to_fast_value_and_append_to_json_term;
+use crate::json_utils::{
+    convert_to_fast_value_and_append_to_json_term, split_json_path, term_from_json_paths,
+};
 use crate::query::range_query::{is_type_valid_for_fastfield_range_query, RangeQuery};
 use crate::query::{
     AllQuery, BooleanQuery, BoostQuery, EmptyQuery, FuzzyTermQuery, Occur, PhrasePrefixQuery,
@@ -964,8 +966,14 @@ fn generate_literals_for_json_object(
     let index_record_option = text_options.index_option();
     let mut logical_literals = Vec::new();
 
-    let get_term_with_path =
-        || Term::from_field_json_path(field, json_path, json_options.is_expand_dots_enabled());
+    let paths = split_json_path(json_path);
+    let get_term_with_path = || {
+        term_from_json_paths(
+            field,
+            paths.iter().map(|el| el.as_str()),
+            json_options.is_expand_dots_enabled(),
+        )
+    };
 
     // Try to convert the phrase to a fast value
     if let Some(term) = convert_to_fast_value_and_append_to_json_term(get_term_with_path(), phrase)

src/schema/document/de.rs

@@ -960,19 +960,13 @@ mod tests {
             "my-third-key".to_string(),
             crate::schema::OwnedValue::F64(123.0),
         );
-        assert_eq!(
-            value,
-            crate::schema::OwnedValue::Object(expected_object.into_iter().collect())
-        );
+        assert_eq!(value, crate::schema::OwnedValue::Object(expected_object));
 
         let object = serde_json::Map::new();
         let result = serialize_value(ReferenceValue::Object(JsonObjectIter(object.iter())));
         let value = deserialize_value(result);
         let expected_object = BTreeMap::new();
-        assert_eq!(
-            value,
-            crate::schema::OwnedValue::Object(expected_object.into_iter().collect())
-        );
+        assert_eq!(value, crate::schema::OwnedValue::Object(expected_object));
 
         let mut object = serde_json::Map::new();
         object.insert("my-first-key".into(), serde_json::Value::Null);
@@ -984,10 +978,7 @@ mod tests {
         expected_object.insert("my-first-key".to_string(), crate::schema::OwnedValue::Null);
         expected_object.insert("my-second-key".to_string(), crate::schema::OwnedValue::Null);
         expected_object.insert("my-third-key".to_string(), crate::schema::OwnedValue::Null);
-        assert_eq!(
-            value,
-            crate::schema::OwnedValue::Object(expected_object.into_iter().collect())
-        );
+        assert_eq!(value, crate::schema::OwnedValue::Object(expected_object));
     }
 
     #[test]
@@ -1064,10 +1055,7 @@ mod tests {
                 .collect(),
             ),
         );
-        assert_eq!(
-            value,
-            crate::schema::OwnedValue::Object(expected_object.into_iter().collect())
-        );
+        assert_eq!(value, crate::schema::OwnedValue::Object(expected_object));
 
         // Some more extreme nesting that might behave weirdly
         let mut object = serde_json::Map::new();
@@ -1089,9 +1077,6 @@ mod tests {
                 OwnedValue::Array(vec![OwnedValue::Null]),
             ])]),
         );
-        assert_eq!(
-            value,
-            OwnedValue::Object(expected_object.into_iter().collect())
-        );
+        assert_eq!(value, OwnedValue::Object(expected_object));
     }
 }

src/schema/document/mod.rs

@@ -5,24 +5,22 @@
 //! - [Value] which provides tantivy with a way to access the document's values in a common way
 //!   without performing any additional allocations.
 //! - [DocumentDeserialize] which implements the necessary code to deserialize the document from the
-//!   doc store. If you are fine with fetching [TantivyDocument] from the doc store, you can skip
-//!   implementing this trait for your type.
+//!   doc store.
 //!
 //! Tantivy provides a few out-of-box implementations of these core traits to provide
 //! some simple usage if you don't want to implement these traits on a custom type yourself.
 //!
 //! # Out-of-box document implementations
-//! - [TantivyDocument] the old document type used by Tantivy before the trait based approach was
+//! - [Document] the old document type used by Tantivy before the trait based approach was
 //!   implemented. This type is still valid and provides all of the original behaviour you might
 //!   expect.
-//! - `BTreeMap<Field, OwnedValue>` a mapping of field_ids to their relevant schema value using a
+//! - `BTreeMap<Field, Value>` a mapping of field_ids to their relevant schema value using a
 //!   BTreeMap.
-//! - `HashMap<Field, OwnedValue>` a mapping of field_ids to their relevant schema value using a
-//!   HashMap.
+//! - `HashMap<Field, Value>` a mapping of field_ids to their relevant schema value using a HashMap.
 //!
 //! # Implementing your custom documents
 //! Often in larger projects or higher performance applications you want to avoid the extra overhead
-//! of converting your own types to the [TantivyDocument] type, this can often save you a
+//! of converting your own types to the Tantivy [Document] type, this can often save you a
 //! significant amount of time when indexing by avoiding the additional allocations.
 //!
 //! ### Important Note
@@ -48,7 +46,6 @@
 //!
 //! impl Document for MyCustomDocument {
 //!     // The value type produced by the `iter_fields_and_values` iterator.
-//!     // tantivy already implements the Value trait for serde_json::Value.
 //!     type Value<'a> = &'a serde_json::Value;
 //!     // The iterator which is produced by `iter_fields_and_values`.
 //!     // Often this is a simple new-type wrapper unless you like super long generics.
@@ -97,11 +94,10 @@
 //! implementation for.
 //!
 //! ## Implementing custom values
-//! In order to allow documents to return custom types, they must implement
-//! the [Value] trait which provides a way for Tantivy to get a `ReferenceValue` that it can then
-//! index and store.
 //! Internally, Tantivy only works with `ReferenceValue` which is an enum that tries to borrow
-//! as much data as it can
+//! as much data as it can, in order to allow documents to return custom types, they must implement
+//! the `Value` trait which provides a way for Tantivy to get a `ReferenceValue` that it can then
+//! index and store.
 //!
 //! Values can just as easily be customised as documents by implementing the `Value` trait.
 //!
@@ -109,9 +105,9 @@
 //! hold references of the data held by the parent [Document] which can then be passed
 //! on to the [ReferenceValue].
 //!
-//! This is why [Value] is implemented for `&'a serde_json::Value` and
-//! [&'a tantivy::schema::document::OwnedValue](OwnedValue) but not for their owned counterparts, as
-//! we cannot satisfy the lifetime bounds necessary when indexing the documents.
+//! This is why `Value` is implemented for `&'a serde_json::Value` and `&'a
+//! tantivy::schema::Value` but not for their owned counterparts, as we cannot satisfy the lifetime
+//! bounds necessary when indexing the documents.
 //!
 //! ### A note about returning values
 //! The custom value type does not have to be the type stored by the document, instead the

src/schema/document/owned_value.rs

@@ -1,4 +1,4 @@
-use std::collections::BTreeMap;
+use std::collections::{btree_map, BTreeMap};
 use std::fmt;
 use std::net::Ipv6Addr;
 
@@ -45,7 +45,7 @@ pub enum OwnedValue {
     /// A set of values.
     Array(Vec<Self>),
     /// Dynamic object value.
-    Object(Vec<(String, Self)>),
+    Object(BTreeMap<String, Self>),
     /// IpV6 Address. Internally there is no IpV4, it needs to be converted to `Ipv6Addr`.
     IpAddr(Ipv6Addr),
 }
@@ -148,10 +148,10 @@ impl ValueDeserialize for OwnedValue {
 
             fn visit_object<'de, A>(&self, mut access: A) -> Result<Self::Value, DeserializeError>
             where A: ObjectAccess<'de> {
-                let mut elements = Vec::with_capacity(access.size_hint());
+                let mut elements = BTreeMap::new();
 
                 while let Some((key, value)) = access.next_entry()? {
-                    elements.push((key, value));
+                    elements.insert(key, value);
                 }
 
                 Ok(OwnedValue::Object(elements))
@@ -167,7 +167,6 @@ impl Eq for OwnedValue {}
 impl serde::Serialize for OwnedValue {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where S: serde::Serializer {
-        use serde::ser::SerializeMap;
         match *self {
             OwnedValue::Null => serializer.serialize_unit(),
             OwnedValue::Str(ref v) => serializer.serialize_str(v),
@@ -181,13 +180,7 @@ impl serde::Serialize for OwnedValue {
             }
             OwnedValue::Facet(ref facet) => facet.serialize(serializer),
             OwnedValue::Bytes(ref bytes) => serializer.serialize_str(&BASE64.encode(bytes)),
-            OwnedValue::Object(ref obj) => {
-                let mut map = serializer.serialize_map(Some(obj.len()))?;
-                for &(ref k, ref v) in obj {
-                    map.serialize_entry(k, v)?;
-                }
-                map.end()
-            }
+            OwnedValue::Object(ref obj) => obj.serialize(serializer),
             OwnedValue::IpAddr(ref ip_v6) => {
                 // Ensure IpV4 addresses get serialized as IpV4, but excluding IpV6 loopback.
                 if let Some(ip_v4) = ip_v6.to_ipv4_mapped() {
@@ -255,10 +248,12 @@ impl<'de> serde::Deserialize<'de> for OwnedValue {
 
             fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
             where A: MapAccess<'de> {
-                let mut object = map.size_hint().map(Vec::with_capacity).unwrap_or_default();
+                let mut object = BTreeMap::new();
+
                 while let Some((key, value)) = map.next_entry()? {
-                    object.push((key, value));
+                    object.insert(key, value);
                 }
+
                 Ok(OwnedValue::Object(object))
             }
         }
@@ -368,8 +363,7 @@ impl From<PreTokenizedString> for OwnedValue {
 
 impl From<BTreeMap<String, OwnedValue>> for OwnedValue {
     fn from(object: BTreeMap<String, OwnedValue>) -> OwnedValue {
-        let key_values = object.into_iter().collect();
-        OwnedValue::Object(key_values)
+        OwnedValue::Object(object)
     }
 }
 
@@ -423,16 +417,18 @@ impl From<serde_json::Value> for OwnedValue {
 
 impl From<serde_json::Map<String, serde_json::Value>> for OwnedValue {
     fn from(map: serde_json::Map<String, serde_json::Value>) -> Self {
-        let object: Vec<(String, OwnedValue)> = map
-            .into_iter()
-            .map(|(key, value)| (key, OwnedValue::from(value)))
-            .collect();
+        let mut object = BTreeMap::new();
+
+        for (key, value) in map {
+            object.insert(key, OwnedValue::from(value));
+        }
+
         OwnedValue::Object(object)
     }
 }
 
 /// A wrapper type for iterating over a serde_json object producing reference values.
-pub struct ObjectMapIter<'a>(std::slice::Iter<'a, (String, OwnedValue)>);
+pub struct ObjectMapIter<'a>(btree_map::Iter<'a, String, OwnedValue>);
 
 impl<'a> Iterator for ObjectMapIter<'a> {
     type Item = (&'a str, &'a OwnedValue);

src/schema/indexing_term.rs

@@ -0,0 +1,147 @@
+use std::net::Ipv6Addr;
+
+use columnar::{MonotonicallyMappableToU128, MonotonicallyMappableToU64};
+
+use super::date_time_options::DATE_TIME_PRECISION_INDEXED;
+use super::Field;
+use crate::fastfield::FastValue;
+use crate::schema::Type;
+use crate::DateTime;
+
+/// IndexingTerm represents is the serialized information of a term during indexing.
+/// It's a serialized representation over different types.
+///
+/// It actually wraps a `Vec<u8>`.
+///
+/// The format is as follow:
+/// `[field id: u32][serialized value]`
+///
+/// For JSON it equals to:
+/// `[field id: u32][path id: u32][type code: u8][serialized value]`
+///
+/// The format is chosen to easily partition the terms by field during serialization, as all terms
+/// are stored in one hashmap.
+#[derive(Clone)]
+pub(crate) struct IndexingTerm(Vec<u8>);
+
+/// The number of bytes used as for the field id by `Term`.
+const FIELD_ID_LENGTH: usize = 4;
+
+impl IndexingTerm {
+    /// Create a new IndexingTerm.
+    pub fn new() -> IndexingTerm {
+        let mut data = Vec::with_capacity(FIELD_ID_LENGTH + 32);
+        data.resize(FIELD_ID_LENGTH, 0u8);
+        IndexingTerm(data)
+    }
+
+    /// Is empty if there are no value bytes.
+    pub fn is_empty(&self) -> bool {
+        self.0.len() == FIELD_ID_LENGTH
+    }
+
+    /// Removes the value_bytes and set the field
+    pub(crate) fn clear_with_field(&mut self, field: Field) {
+        self.truncate_value_bytes(0);
+        self.0[0..4].clone_from_slice(field.field_id().to_be_bytes().as_ref());
+    }
+
+    /// Sets a u64 value in the term.
+    ///
+    /// U64 are serialized using (8-byte) BigEndian
+    /// representation.
+    /// The use of BigEndian has the benefit of preserving
+    /// the natural order of the values.
+    pub fn set_u64(&mut self, val: u64) {
+        self.set_fast_value(val);
+    }
+
+    /// Sets a `DateTime` value in the term.
+    pub fn set_date(&mut self, val: DateTime) {
+        self.set_fast_value(val);
+    }
+
+    /// Sets a `i64` value in the term.
+    pub fn set_i64(&mut self, val: i64) {
+        self.set_fast_value(val);
+    }
+
+    /// Sets a `f64` value in the term.
+    pub fn set_f64(&mut self, val: f64) {
+        self.set_fast_value(val);
+    }
+
+    /// Sets a `bool` value in the term.
+    pub fn set_bool(&mut self, val: bool) {
+        self.set_fast_value(val);
+    }
+
+    fn set_fast_value<T: FastValue>(&mut self, val: T) {
+        self.truncate_value_bytes(0);
+        self.append_fast_value(val);
+    }
+
+    /// Sets a `Ipv6Addr` value in the term.
+    pub fn set_ip_addr(&mut self, val: Ipv6Addr) {
+        self.set_value_bytes(val.to_u128().to_be_bytes().as_ref());
+    }
+
+    /// Sets the value bytes of the term.
+    pub fn set_value_bytes(&mut self, bytes: &[u8]) {
+        self.truncate_value_bytes(0);
+        self.0.extend(bytes);
+    }
+
+    /// Append a type marker + fast value to a term.
+    /// This is used in JSON type to append a fast value after the path.
+    ///
+    /// It will not clear existing bytes.
+    pub(crate) fn append_type_and_fast_value<T: FastValue>(&mut self, val: T) {
+        self.0.push(T::to_type().to_code());
+        self.append_fast_value(val)
+    }
+
+    /// Append a fast value to a term.
+    ///
+    /// It will not clear existing bytes.
+    pub fn append_fast_value<T: FastValue>(&mut self, val: T) {
+        let value = if T::to_type() == Type::Date {
+            DateTime::from_u64(val.to_u64())
+                .truncate(DATE_TIME_PRECISION_INDEXED)
+                .to_u64()
+        } else {
+            val.to_u64()
+        };
+        self.0.extend(value.to_be_bytes().as_ref());
+    }
+
+    /// Truncates the value bytes of the term. Value and field type stays the same.
+    pub fn truncate_value_bytes(&mut self, len: usize) {
+        self.0.truncate(len + FIELD_ID_LENGTH);
+    }
+
+    /// The length of the bytes.
+    pub fn len_bytes(&self) -> usize {
+        self.0.len() - FIELD_ID_LENGTH
+    }
+
+    /// Appends bytes to the Term.
+    ///
+    /// This function returns the segment that has just been added.
+    #[inline]
+    pub fn append_bytes(&mut self, bytes: &[u8]) {
+        self.0.extend_from_slice(bytes);
+    }
+
+    /// Returns the serialized representation of Term.
+    /// This includes field_id, value bytes
+    #[inline]
+    pub fn serialized_for_hashmap(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+pub fn get_field_from_indexing_term(bytes: &[u8]) -> Field {
+    let field_id_bytes: [u8; 4] = bytes[..4].try_into().unwrap();
+    Field::from_field_id(u32::from_be_bytes(field_id_bytes))
+}

src/schema/mod.rs

@@ -109,6 +109,7 @@
 pub mod document;
 mod facet;
 mod facet_options;
+pub(crate) mod indexing_term;
 mod schema;
 pub(crate) mod term;
 

src/schema/term.rs

@@ -1,15 +1,13 @@
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
 use std::net::Ipv6Addr;
 use std::{fmt, str};
 
 use columnar::{MonotonicallyMappableToU128, MonotonicallyMappableToU64};
 use common::json_path_writer::{JSON_END_OF_PATH, JSON_PATH_SEGMENT_SEP_STR};
-use common::JsonPathWriter;
 
 use super::date_time_options::DATE_TIME_PRECISION_INDEXED;
 use super::Field;
 use crate::fastfield::FastValue;
-use crate::json_utils::split_json_path;
 use crate::schema::{Facet, Type};
 use crate::DateTime;
 
@@ -20,59 +18,45 @@ use crate::DateTime;
 /// 4 bytes are the field id, and the last byte is the type.
 ///
 /// The serialized value `ValueBytes` is considered everything after the 4 first bytes (term id).
-#[derive(Clone)]
-pub struct Term<B = Vec<u8>>(B)
-where B: AsRef<[u8]>;
+#[derive(Clone, Hash, PartialEq, Ord, PartialOrd, Eq)]
+pub struct Term(Vec<u8>);
+impl Default for Term {
+    fn default() -> Self {
+        Self::new()
+    }
+}
 
 /// The number of bytes used as metadata by `Term`.
 const TERM_METADATA_LENGTH: usize = 5;
 
 impl Term {
-    /// Create a new Term with a buffer with a given capacity.
-    pub fn with_capacity(capacity: usize) -> Term {
-        let mut data = Vec::with_capacity(TERM_METADATA_LENGTH + capacity);
+    /// Create a new Term
+    pub fn new() -> Term {
+        let mut data = Vec::with_capacity(TERM_METADATA_LENGTH + 32);
         data.resize(TERM_METADATA_LENGTH, 0u8);
         Term(data)
     }
 
-    /// Creates a term from a json path.
-    ///
-    /// The json path can address a nested value in a JSON object.
-    /// e.g. `{"k8s": {"node": {"id": 5}}}` can be addressed via `k8s.node.id`.
-    ///
-    /// In case there are dots in the field name, and the `expand_dots_enabled` parameter is not
-    /// set they need to be escaped with a backslash.
-    /// e.g. `{"k8s.node": {"id": 5}}` can be addressed via `k8s\.node.id`.
-    pub fn from_field_json_path(field: Field, json_path: &str, expand_dots_enabled: bool) -> Term {
-        let paths = split_json_path(json_path);
-        let mut json_path = JsonPathWriter::with_expand_dots(expand_dots_enabled);
-        for path in paths {
-            json_path.push(&path);
-        }
-        json_path.set_end();
-        let mut term = Term::with_type_and_field(Type::Json, field);
-
-        term.append_bytes(json_path.as_str().as_bytes());
-
-        term
-    }
-
     pub(crate) fn with_type_and_field(typ: Type, field: Field) -> Term {
-        let mut term = Self::with_capacity(8);
-        term.set_field_and_type(field, typ);
-        term
+        Self::with_bytes_and_field_and_payload(typ, field, &[])
     }
 
     fn with_bytes_and_field_and_payload(typ: Type, field: Field, bytes: &[u8]) -> Term {
-        let mut term = Self::with_capacity(bytes.len());
+        let mut term = Self::new();
         term.set_field_and_type(field, typ);
         term.0.extend_from_slice(bytes);
         term
     }
 
+    /// Sets a fast value in the term.
+    ///
+    /// fast values are converted to u64 and then serialized using (8-byte) BigEndian
+    /// representation.
+    /// The use of BigEndian has the benefit of preserving
+    /// the natural order of the values.
     fn from_fast_value<T: FastValue>(field: Field, val: &T) -> Term {
         let mut term = Self::with_type_and_field(T::to_type(), field);
-        term.set_u64(val.to_u64());
+        term.set_bytes(val.to_u64().to_be_bytes().as_ref());
         term
     }
 
@@ -94,7 +78,7 @@ impl Term {
     /// Builds a term given a field, and a `Ipv6Addr`-value
     pub fn from_field_ip_addr(field: Field, ip_addr: Ipv6Addr) -> Term {
         let mut term = Self::with_type_and_field(Type::IpAddr, field);
-        term.set_ip_addr(ip_addr);
+        term.set_bytes(ip_addr.to_u128().to_be_bytes().as_ref());
         term
     }
 
@@ -139,57 +123,17 @@ impl Term {
         Term::with_bytes_and_field_and_payload(Type::Bytes, field, bytes)
     }
 
-    /// Removes the value_bytes and set the field and type code.
-    pub(crate) fn clear_with_field_and_type(&mut self, typ: Type, field: Field) {
-        self.truncate_value_bytes(0);
-        self.set_field_and_type(field, typ);
-    }
-
     /// Removes the value_bytes and set the type code.
     pub fn clear_with_type(&mut self, typ: Type) {
         self.truncate_value_bytes(0);
         self.0[4] = typ.to_code();
     }
 
-    /// Sets a u64 value in the term.
-    ///
-    /// U64 are serialized using (8-byte) BigEndian
-    /// representation.
-    /// The use of BigEndian has the benefit of preserving
-    /// the natural order of the values.
-    pub fn set_u64(&mut self, val: u64) {
-        self.set_fast_value(val);
-    }
-
-    /// Sets a `i64` value in the term.
-    pub fn set_i64(&mut self, val: i64) {
-        self.set_fast_value(val);
-    }
-
-    /// Sets a `DateTime` value in the term.
-    pub fn set_date(&mut self, date: DateTime) {
-        self.set_fast_value(date);
-    }
-
-    /// Sets a `f64` value in the term.
-    pub fn set_f64(&mut self, val: f64) {
-        self.set_fast_value(val);
-    }
-
-    /// Sets a `bool` value in the term.
-    pub fn set_bool(&mut self, val: bool) {
-        self.set_fast_value(val);
-    }
-
-    fn set_fast_value<T: FastValue>(&mut self, val: T) {
-        self.set_bytes(val.to_u64().to_be_bytes().as_ref());
-    }
-
     /// Append a type marker + fast value to a term.
     /// This is used in JSON type to append a fast value after the path.
     ///
     /// It will not clear existing bytes.
-    pub fn append_type_and_fast_value<T: FastValue>(&mut self, val: T) {
+    pub(crate) fn append_type_and_fast_value<T: FastValue>(&mut self, val: T) {
         self.0.push(T::to_type().to_code());
         let value = if T::to_type() == Type::Date {
             DateTime::from_u64(val.to_u64())
@@ -205,18 +149,13 @@ impl Term {
     /// This is used in JSON type to append a str after the path.
     ///
     /// It will not clear existing bytes.
-    pub fn append_type_and_str(&mut self, val: &str) {
+    pub(crate) fn append_type_and_str(&mut self, val: &str) {
         self.0.push(Type::Str.to_code());
         self.0.extend(val.as_bytes().as_ref());
     }
 
-    /// Sets a `Ipv6Addr` value in the term.
-    pub fn set_ip_addr(&mut self, val: Ipv6Addr) {
-        self.set_bytes(val.to_u128().to_be_bytes().as_ref());
-    }
-
     /// Sets the value of a `Bytes` field.
-    pub fn set_bytes(&mut self, bytes: &[u8]) {
+    fn set_bytes(&mut self, bytes: &[u8]) {
         self.truncate_value_bytes(0);
         self.0.extend(bytes);
     }
@@ -226,11 +165,6 @@ impl Term {
         self.0.truncate(len + TERM_METADATA_LENGTH);
     }
 
-    /// The length of the bytes.
-    pub fn len_bytes(&self) -> usize {
-        self.0.len() - TERM_METADATA_LENGTH
-    }
-
     /// Appends value bytes to the Term.
     ///
     /// This function returns the segment that has just been added.
@@ -241,57 +175,19 @@ impl Term {
         &mut self.0[len_before..]
     }
 
-    /// Appends json path bytes to the Term.
-    /// If the path contains 0 bytes, they are replaced by a "0" string.
-    /// The 0 byte is used to mark the end of the path.
-    ///
-    /// This function returns the segment that has just been added.
-    #[inline]
-    pub fn append_path(&mut self, bytes: &[u8]) -> &mut [u8] {
-        let len_before = self.0.len();
-        if bytes.contains(&0u8) {
-            self.0
-                .extend(bytes.iter().map(|&b| if b == 0 { b'0' } else { b }));
-        } else {
-            self.0.extend_from_slice(bytes);
-        }
-        &mut self.0[len_before..]
-    }
-}
-
-impl<B> Term<B>
-where B: AsRef<[u8]>
-{
-    /// Wraps a object holding bytes
-    pub fn wrap(data: B) -> Term<B> {
-        Term(data)
-    }
-
     /// Return the type of the term.
     pub fn typ(&self) -> Type {
         self.value().typ()
     }
 
-    /// Returns the field.
-    pub fn field(&self) -> Field {
-        let field_id_bytes: [u8; 4] = (&self.0.as_ref()[..4]).try_into().unwrap();
-        Field::from_field_id(u32::from_be_bytes(field_id_bytes))
-    }
-
     /// Returns the serialized representation of the value.
     /// (this does neither include the field id nor the value type.)
     ///
     /// If the term is a string, its value is utf-8 encoded.
     /// If the term is a u64, its value is encoded according
     /// to `byteorder::BigEndian`.
-    pub fn serialized_value_bytes(&self) -> &[u8] {
-        &self.0.as_ref()[TERM_METADATA_LENGTH..]
-    }
-
-    /// Returns the value of the term.
-    /// address or JSON path + value. (this does not include the field.)
-    pub fn value(&self) -> ValueBytes<&[u8]> {
-        ValueBytes::wrap(&self.0.as_ref()[4..])
+    pub(crate) fn serialized_value_bytes(&self) -> &[u8] {
+        &self.0[TERM_METADATA_LENGTH..]
     }
 
     /// Returns the serialized representation of Term.
@@ -300,9 +196,22 @@ where B: AsRef<[u8]>
     /// Do NOT rely on this byte representation in the index.
     /// This value is likely to change in the future.
     #[inline]
+    #[cfg(test)]
     pub fn serialized_term(&self) -> &[u8] {
         self.0.as_ref()
     }
+
+    /// Returns the field.
+    pub fn field(&self) -> Field {
+        let field_id_bytes: [u8; 4] = (&self.0[..4]).try_into().unwrap();
+        Field::from_field_id(u32::from_be_bytes(field_id_bytes))
+    }
+
+    /// Returns the value of the term.
+    /// address or JSON path + value. (this does not include the field.)
+    pub fn value(&self) -> ValueBytes<&[u8]> {
+        ValueBytes::wrap(&self.0[4..])
+    }
 }
 
 /// ValueBytes represents a serialized value.
@@ -333,18 +242,10 @@ where B: AsRef<[u8]>
     }
 
     /// Return the type of the term.
-    pub fn typ(&self) -> Type {
+    pub(crate) fn typ(&self) -> Type {
         Type::from_code(self.typ_code()).expect("The term has an invalid type code")
     }
 
-    /// Returns the `u64` value stored in a term.
-    ///
-    /// Returns `None` if the term is not of the u64 type, or if the term byte representation
-    /// is invalid.
-    pub fn as_u64(&self) -> Option<u64> {
-        self.get_fast_type::<u64>()
-    }
-
     fn get_fast_type<T: FastValue>(&self) -> Option<T> {
         if self.typ() != T::to_type() {
             return None;
@@ -354,38 +255,6 @@ where B: AsRef<[u8]>
         Some(T::from_u64(value_u64))
     }
 
-    /// Returns the `i64` value stored in a term.
-    ///
-    /// Returns `None` if the term is not of the i64 type, or if the term byte representation
-    /// is invalid.
-    pub fn as_i64(&self) -> Option<i64> {
-        self.get_fast_type::<i64>()
-    }
-
-    /// Returns the `f64` value stored in a term.
-    ///
-    /// Returns `None` if the term is not of the f64 type, or if the term byte representation
-    /// is invalid.
-    pub fn as_f64(&self) -> Option<f64> {
-        self.get_fast_type::<f64>()
-    }
-
-    /// Returns the `bool` value stored in a term.
-    ///
-    /// Returns `None` if the term is not of the bool type, or if the term byte representation
-    /// is invalid.
-    pub fn as_bool(&self) -> Option<bool> {
-        self.get_fast_type::<bool>()
-    }
-
-    /// Returns the `Date` value stored in a term.
-    ///
-    /// Returns `None` if the term is not of the Date type, or if the term byte representation
-    /// is invalid.
-    pub fn as_date(&self) -> Option<DateTime> {
-        self.get_fast_type::<DateTime>()
-    }
-
     /// Returns the text associated with the term.
     ///
     /// Returns `None` if the field is not of string type
@@ -401,7 +270,7 @@ where B: AsRef<[u8]>
     ///
     /// Returns `None` if the field is not of facet type
     /// or if the bytes are not valid utf-8.
-    pub fn as_facet(&self) -> Option<Facet> {
+    pub(crate) fn as_facet(&self) -> Option<Facet> {
         if self.typ() != Type::Facet {
             return None;
         }
@@ -412,7 +281,7 @@ where B: AsRef<[u8]>
     /// Returns the bytes associated with the term.
     ///
     /// Returns `None` if the field is not of bytes type.
-    pub fn as_bytes(&self) -> Option<&[u8]> {
+    pub(crate) fn as_bytes(&self) -> Option<&[u8]> {
         if self.typ() != Type::Bytes {
             return None;
         }
@@ -420,7 +289,7 @@ where B: AsRef<[u8]>
     }
 
     /// Returns a `Ipv6Addr` value from the term.
-    pub fn as_ip_addr(&self) -> Option<Ipv6Addr> {
+    pub(crate) fn as_ip_addr(&self) -> Option<Ipv6Addr> {
         if self.typ() != Type::IpAddr {
             return None;
         }
@@ -428,15 +297,6 @@ where B: AsRef<[u8]>
         Some(Ipv6Addr::from_u128(ip_u128))
     }
 
-    /// Returns the json path type.
-    ///
-    /// Returns `None` if the value is not JSON.
-    pub fn json_path_type(&self) -> Option<Type> {
-        let json_value_bytes = self.as_json_value_bytes()?;
-
-        Some(json_value_bytes.typ())
-    }
-
     /// Returns the json path bytes (including the JSON_END_OF_PATH byte),
     /// and the encoded ValueBytes after the json path.
     ///
@@ -453,18 +313,6 @@ where B: AsRef<[u8]>
         Some((json_path_bytes, ValueBytes::wrap(term)))
     }
 
-    /// Returns the encoded ValueBytes after the json path.
-    ///
-    /// Returns `None` if the value is not JSON.
-    pub(crate) fn as_json_value_bytes(&self) -> Option<ValueBytes<&[u8]>> {
-        if self.typ() != Type::Json {
-            return None;
-        }
-        let bytes = self.value_bytes();
-        let pos = bytes.iter().cloned().position(|b| b == JSON_END_OF_PATH)?;
-        Some(ValueBytes::wrap(&bytes[pos + 1..]))
-    }
-
     /// Returns the serialized value of ValueBytes without the type.
     fn value_bytes(&self) -> &[u8] {
         &self.0.as_ref()[1..]
@@ -487,20 +335,20 @@ where B: AsRef<[u8]>
                 write_opt(f, s)?;
             }
             Type::U64 => {
-                write_opt(f, self.as_u64())?;
+                write_opt(f, self.get_fast_type::<u64>())?;
             }
             Type::I64 => {
-                write_opt(f, self.as_i64())?;
+                write_opt(f, self.get_fast_type::<i64>())?;
             }
             Type::F64 => {
-                write_opt(f, self.as_f64())?;
+                write_opt(f, self.get_fast_type::<f64>())?;
             }
             Type::Bool => {
-                write_opt(f, self.as_bool())?;
+                write_opt(f, self.get_fast_type::<bool>())?;
             }
             // TODO pretty print these types too.
             Type::Date => {
-                write_opt(f, self.as_date())?;
+                write_opt(f, self.get_fast_type::<DateTime>())?;
             }
             Type::Facet => {
                 write_opt(f, self.as_facet())?;
@@ -526,40 +374,6 @@ where B: AsRef<[u8]>
     }
 }
 
-impl<B> Ord for Term<B>
-where B: AsRef<[u8]>
-{
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.serialized_term().cmp(other.serialized_term())
-    }
-}
-
-impl<B> PartialOrd for Term<B>
-where B: AsRef<[u8]>
-{
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl<B> PartialEq for Term<B>
-where B: AsRef<[u8]>
-{
-    fn eq(&self, other: &Self) -> bool {
-        self.serialized_term() == other.serialized_term()
-    }
-}
-
-impl<B> Eq for Term<B> where B: AsRef<[u8]> {}
-
-impl<B> Hash for Term<B>
-where B: AsRef<[u8]>
-{
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.0.as_ref().hash(state)
-    }
-}
-
 fn write_opt<T: std::fmt::Debug>(f: &mut fmt::Formatter, val_opt: Option<T>) -> fmt::Result {
     if let Some(val) = val_opt {
         write!(f, "{val:?}")?;
@@ -567,13 +381,11 @@ fn write_opt<T: std::fmt::Debug>(f: &mut fmt::Formatter, val_opt: Option<T>) ->
     Ok(())
 }
 
-impl<B> fmt::Debug for Term<B>
-where B: AsRef<[u8]>
-{
+impl fmt::Debug for Term {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let field_id = self.field().field_id();
         write!(f, "Term(field={field_id}, ")?;
-        let value_bytes = ValueBytes::wrap(&self.0.as_ref()[4..]);
+        let value_bytes = ValueBytes::wrap(&self.0[4..]);
         value_bytes.debug_value_bytes(f)?;
         write!(f, ")",)?;
         Ok(())
@@ -595,38 +407,4 @@ mod tests {
         assert_eq!(term.typ(), Type::Str);
         assert_eq!(term.value().as_str(), Some("test"))
     }
-
-    /// Size (in bytes) of the buffer of a fast value (u64, i64, f64, or date) term.
-    /// <field> + <type byte> + <value len>
-    ///
-    /// - <field> is a big endian encoded u32 field id
-    /// - <type_byte>'s most significant bit expresses whether the term is a json term or not
-    /// The remaining 7 bits are used to encode the type of the value.
-    /// If this is a JSON term, the type is the type of the leaf of the json.
-    ///
-    /// - <value> is,  if this is not the json term, a binary representation specific to the type.
-    /// If it is a JSON Term, then it is prepended with the path that leads to this leaf value.
-    const FAST_VALUE_TERM_LEN: usize = 4 + 1 + 8;
-
-    #[test]
-    pub fn test_term_u64() {
-        let mut schema_builder = Schema::builder();
-        let count_field = schema_builder.add_u64_field("count", INDEXED);
-        let term = Term::from_field_u64(count_field, 983u64);
-        assert_eq!(term.field(), count_field);
-        assert_eq!(term.typ(), Type::U64);
-        assert_eq!(term.serialized_term().len(), FAST_VALUE_TERM_LEN);
-        assert_eq!(term.value().as_u64(), Some(983u64))
-    }
-
-    #[test]
-    pub fn test_term_bool() {
-        let mut schema_builder = Schema::builder();
-        let bool_field = schema_builder.add_bool_field("bool", INDEXED);
-        let term = Term::from_field_bool(bool_field, true);
-        assert_eq!(term.field(), bool_field);
-        assert_eq!(term.typ(), Type::Bool);
-        assert_eq!(term.serialized_term().len(), FAST_VALUE_TERM_LEN);
-        assert_eq!(term.value().as_bool(), Some(true))
-    }
 }