Skip to content

web search done right

random access row ordered fields for ints, floats and bools.

Mikkel Denkerffb2a2a0a071
diff --git a/Cargo.lock b/Cargo.lock
index 555408c4..5bb40029 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5242,6 +5242,7 @@ dependencies = [
"serde",
"serde_json",
"smallvec",
+ "strum 0.26.3",
"tempfile",
"thiserror",
"time",
diff --git a/crates/tantivy/Cargo.toml b/crates/tantivy/Cargo.toml
index 86e823ab..27d47866 100644
--- a/crates/tantivy/Cargo.toml
+++ b/crates/tantivy/Cargo.toml
@@ -49,6 +49,7 @@ rustc-hash.workspace = true
serde.workspace = true
serde_json.workspace = true
smallvec.workspace = true
+strum.workspace = true
tempfile = {workspace = true, optional = true}
thiserror.workspace = true
time.workspace = true
diff --git a/crates/tantivy/src/index/index_meta.rs b/crates/tantivy/src/index/index_meta.rs
index 73822d44..72b83f9e 100644
--- a/crates/tantivy/src/index/index_meta.rs
+++ b/crates/tantivy/src/index/index_meta.rs
@@ -139,7 +139,8 @@ impl SegmentMeta {
SegmentComponent::Terms => ".term".to_string(),
SegmentComponent::Store => ".store".to_string(),
SegmentComponent::TempStore => ".store.temp".to_string(),
- SegmentComponent::ColumnFields => ".fast".to_string(),
+ SegmentComponent::ColumnFields => ".col".to_string(),
+ SegmentComponent::RowFields => ".row".to_string(),
SegmentComponent::FieldNorms => ".fieldnorm".to_string(),
});
PathBuf::from(path)
diff --git a/crates/tantivy/src/index/segment_component.rs b/crates/tantivy/src/index/segment_component.rs
index 75714069..e39e48af 100644
--- a/crates/tantivy/src/index/segment_component.rs
+++ b/crates/tantivy/src/index/segment_component.rs
@@ -12,6 +12,8 @@ pub enum SegmentComponent {
Positions,
/// Column-oriented random-access storage of fields.
ColumnFields,
+ /// Row-oriented random-access storage of fields.
+ RowFields,
/// Stores the sum of the length (in terms) of each field for each document.
/// Field norms are stored as a special u64 columnar field.
FieldNorms,
@@ -29,10 +31,11 @@ pub enum SegmentComponent {
impl SegmentComponent {
/// Iterates through the components.
pub fn iterator() -> slice::Iter<'static, SegmentComponent> {
- static SEGMENT_COMPONENTS: [SegmentComponent; 7] = [
+ static SEGMENT_COMPONENTS: [SegmentComponent; 8] = [
SegmentComponent::Postings,
SegmentComponent::Positions,
SegmentComponent::ColumnFields,
+ SegmentComponent::RowFields,
SegmentComponent::FieldNorms,
SegmentComponent::Terms,
SegmentComponent::Store,
diff --git a/crates/tantivy/src/index/segment_reader.rs b/crates/tantivy/src/index/segment_reader.rs
index f41ddb3c..f73554e1 100644
--- a/crates/tantivy/src/index/segment_reader.rs
+++ b/crates/tantivy/src/index/segment_reader.rs
@@ -12,6 +12,7 @@ use crate::error::DataCorruption;
use crate::fieldnorm::{FieldNormReader, FieldNormReaders};
use crate::index::{InvertedIndexReader, Segment, SegmentComponent, SegmentId};
use crate::json_utils::json_path_sep_to_dot;
+use crate::roworder::readers::RowFieldReaders;
use crate::schema::{Field, IndexRecordOption, Schema, Type};
use crate::space_usage::SegmentSpaceUsage;
use crate::store::StoreReader;
@@ -40,6 +41,7 @@ pub struct SegmentReader {
postings_composite: CompositeFile,
positions_composite: CompositeFile,
column_fields_readers: ColumnFieldReaders,
+ row_fields_readers: RowFieldReaders,
fieldnorm_readers: FieldNormReaders,
store_file: FileSlice,
@@ -77,6 +79,11 @@ impl SegmentReader {
&self.column_fields_readers
}
+ /// Accessor to the segment's row field reader.
+ pub fn row_fields(&self) -> &RowFieldReaders {
+ &self.row_fields_readers
+ }
+
/// Accessor to the segment's `Field norms`'s reader.
///
/// Field norms are the length (in tokens) of the fields.
@@ -134,6 +141,8 @@ impl SegmentReader {
let column_fields_readers = ColumnFieldReaders::open(column_fields_data, schema.clone())?;
let fieldnorm_data = segment.open_read(SegmentComponent::FieldNorms)?;
let fieldnorm_readers = FieldNormReaders::open(fieldnorm_data)?;
+ let row_fields_data = segment.open_read(SegmentComponent::RowFields)?;
+ let row_fields_readers = RowFieldReaders::open(row_fields_data)?;
let max_doc = segment.meta().max_doc();
@@ -143,6 +152,7 @@ impl SegmentReader {
termdict_composite,
postings_composite,
column_fields_readers,
+ row_fields_readers,
fieldnorm_readers,
segment_id: segment.id(),
store_file,
@@ -344,6 +354,7 @@ impl SegmentReader {
self.postings_composite.space_usage(),
self.positions_composite.space_usage(),
self.column_fields_readers.space_usage(self.schema())?,
+ self.row_fields_readers.space_usage(self.schema())?,
self.fieldnorm_readers.space_usage(),
self.get_store_reader(0)?.space_usage(),
))
diff --git a/crates/tantivy/src/indexer/merger.rs b/crates/tantivy/src/indexer/merger.rs
index 77944cb7..8a544610 100644
--- a/crates/tantivy/src/indexer/merger.rs
+++ b/crates/tantivy/src/indexer/merger.rs
@@ -76,7 +76,7 @@ impl DeltaComputer {
fn convert_to_merge_order(
columnars: &[&ColumnarReader],
- doc_id_mapping: SegmentDocIdMapping,
+ doc_id_mapping: &SegmentDocIdMapping,
) -> MergeRowOrder {
match doc_id_mapping.mapping_type() {
MappingType::Stacked => MergeRowOrder::Stack(StackMergeOrder::stack(columnars)),
@@ -85,7 +85,7 @@ fn convert_to_merge_order(
// no allocation, no copy.
let new_row_id_to_old_row_id: Vec<RowAddr> = doc_id_mapping
.new_doc_id_to_old_doc_addr
- .into_iter()
+ .iter()
.map(|doc_addr| RowAddr {
segment_ord: doc_addr.segment_ord,
row_id: doc_addr.doc_id,
@@ -197,7 +197,7 @@ impl IndexMerger {
fn write_column_fields(
&self,
column_field_wrt: &mut WritePtr,
- doc_id_mapping: SegmentDocIdMapping,
+ doc_id_mapping: &SegmentDocIdMapping,
) -> crate::Result<()> {
debug_time!("write-columnar-fields");
let required_columns = extract_column_field_required_columns(&self.schema);
@@ -216,6 +216,37 @@ impl IndexMerger {
Ok(())
}
+ fn write_row_fields(
+ &self,
+ row_field_wrt: &mut WritePtr,
+ doc_id_mapping: &SegmentDocIdMapping,
+ ) -> crate::Result<()> {
+ debug_time!("write-row-fields");
+
+ let indexes: Vec<_> = self
+ .readers
+ .iter()
+ .map(|reader| reader.row_fields().row_index())
+ .collect();
+
+ let order = match doc_id_mapping.mapping_type() {
+ MappingType::Stacked => crate::roworder::MergeRowOrder::Stack,
+ MappingType::Shuffled => crate::roworder::MergeRowOrder::Shuffled {
+ addrs: doc_id_mapping
+ .iter_old_doc_addrs()
+ .map(|addr| crate::roworder::MergeAddr {
+ segment_ord: addr.segment_ord as usize,
+ })
+ .collect(),
+ },
+ };
+
+ crate::roworder::merge(&indexes, order, row_field_wrt)
+ .map_err(|_| DataCorruption::comment_only("Failed to merge row fields"))?;
+
+ Ok(())
+ }
+
/// Checks if the readers are disjunct for their sort property and in the correct order to be
/// able to just stack them.
pub(crate) fn is_disjunct_and_sorted_on_sort_property(
@@ -657,7 +688,9 @@ impl IndexMerger {
debug!("write-storagefields");
self.write_storable_fields(serializer.get_store_writer(), &doc_id_mapping)?;
debug!("write-columnfields");
- self.write_column_fields(serializer.get_column_field_write(), doc_id_mapping)?;
+ self.write_column_fields(serializer.get_column_field_write(), &doc_id_mapping)?;
+ debug!("write-rowfields");
+ self.write_row_fields(serializer.get_row_field_write(), &doc_id_mapping)?;
debug!("close-serializer");
serializer.close()?;
@@ -1285,4 +1318,40 @@ mod tests {
assert!(((super::MAX_DOC_LIMIT - 1) as i32) >= 0);
assert!((super::MAX_DOC_LIMIT as i32) < 0);
}
+
+ #[test]
+ fn test_rowfields_merge() -> crate::Result<()> {
+ let mut schema_builder = schema::Schema::builder();
+ let u64_field = schema_builder
+ .add_u64_field("u64", schema::INDEXED | schema::ROW_ORDER | schema::STORED);
+ let f64_field = schema_builder
+ .add_f64_field("f64", schema::INDEXED | schema::ROW_ORDER | schema::STORED);
+
+ let index = Index::create_in_ram(schema_builder.build());
+ let mut writer = index.writer_for_tests()?;
+
+ // Make sure we'll attempt to merge every created segment
+ let mut policy = crate::indexer::LogMergePolicy::default();
+ policy.set_min_num_segments(2);
+ writer.set_merge_policy(Box::new(policy));
+
+ for i in 0..100 {
+ let mut doc = TantivyDocument::new();
+ doc.add_f64(f64_field, 42.0);
+ doc.add_u64(u64_field, 42);
+
+ writer.add_document(doc)?;
+ if i % 5 == 0 {
+ writer.commit()?;
+ }
+ }
+
+ writer.commit()?;
+ writer.wait_merging_threads()?;
+
+ // If a merging thread fails, we should end up with more
+ // than one segment here
+ assert_eq!(1, index.searchable_segments()?.len());
+ Ok(())
+ }
}
diff --git a/crates/tantivy/src/indexer/merger_sorted_index_test.rs b/crates/tantivy/src/indexer/merger_sorted_index_test.rs
index dfe74722..8e2ff8aa 100644
--- a/crates/tantivy/src/indexer/merger_sorted_index_test.rs
+++ b/crates/tantivy/src/indexer/merger_sorted_index_test.rs
@@ -59,6 +59,18 @@ mod tests {
.set_indexed();
let int_field = schema_builder.add_u64_field("intval", int_options);
+ let col1 = NumericOptions::default()
+ .set_row_order()
+ .set_stored()
+ .set_indexed();
+ let col1_field = schema_builder.add_u64_field("col1", col1);
+
+ let col2 = NumericOptions::default()
+ .set_row_order()
+ .set_stored()
+ .set_indexed();
+ let col2_field = schema_builder.add_u64_field("col2", col2);
+
let text_field_options = TextOptions::default()
.set_indexing_options(
TextFieldIndexing::default()
@@ -78,24 +90,30 @@ mod tests {
let mut index_writer = index.writer_for_tests()?;
// segment 1 - range 1-3
- index_writer.add_document(doc!(int_field=>1_u64, text_field => "text"))?;
- index_writer.add_document(doc!(int_field=>3_u64, text_field => "some text"))?;
index_writer.add_document(
- doc!(int_field=>1_u64, text_field=> "deleteme", text_field => "ok text more text"),
+ doc!(int_field=>1_u64, col1_field=>1_u64, col2_field=>2_u64, text_field => "text"),
+ )?;
+ index_writer.add_document(
+ doc!(int_field=>3_u64, col1_field=>3_u64, col2_field=>6_u64, text_field => "some text"),
+ )?;
+ index_writer.add_document(
+ doc!(int_field=>1_u64, col1_field=>1u64, col2_field=>2u64, text_field=> "deleteme", text_field => "ok text more text"),
+ )?;
+ index_writer.add_document(
+ doc!(int_field=>2_u64, col1_field=>2u64, col2_field=>4u64, text_field => "ok text more text"),
)?;
- index_writer.add_document(doc!(int_field=>2_u64, text_field => "ok text more text"))?;
index_writer.commit()?;
// segment 2 - range 1-20 , with force_disjunct_segment_sort_values 10-20
index_writer
- .add_document(doc!(int_field=>20_u64, text_field => "ok text more text"))?;
+ .add_document(doc!(int_field=>20_u64, col1_field=>20u64, col2_field=>40u64, text_field => "ok text more text"))?;
let in_val = if force_disjunct_segment_sort_values {
10_u64
} else {
1
};
- index_writer.add_document(doc!(int_field=>in_val, text_field=> "deleteme" , text_field => "ok text more text"))?;
+ index_writer.add_document(doc!(int_field=>in_val, col1_field=>in_val, col2_field=>2*in_val, text_field=> "deleteme" , text_field => "ok text more text"))?;
index_writer.commit()?;
// segment 3 - range 5-1000, with force_disjunct_segment_sort_values 50-1000
let int_vals = if force_disjunct_segment_sort_values {
@@ -105,11 +123,11 @@ mod tests {
};
index_writer.add_document(
// position of this doc after delete in desc sorting = [2], in disjunct case [1]
- doc!(int_field=>int_vals[0], text_field=> "blubber"),
+ doc!(int_field=>int_vals[0], col1_field=>int_vals[0], col2_field=>2*int_vals[0], text_field=> "blubber"),
)?;
- index_writer.add_document(doc!(int_field=>int_vals[1], text_field=> "deleteme"))?;
+ index_writer.add_document(doc!(int_field=>int_vals[1], col1_field=>int_vals[1], col2_field=>2*int_vals[1], text_field=> "deleteme"))?;
index_writer
- .add_document(doc!(int_field=>1_000u64, text_field => "the biggest num"))?;
+ .add_document(doc!(int_field=>1_000u64, col1_field=>1_000u64, col2_field=>2_000u64, text_field => "the biggest num"))?;
index_writer.commit()?;
}
@@ -275,6 +293,48 @@ mod tests {
Some(1000)
);
}
+
+ // row fields
+ {
+ let col1_field = index.schema().get_field("col1").unwrap();
+ let col2_field = index.schema().get_field("col2").unwrap();
+
+ let row_index = segment_reader.row_fields().row_index();
+
+ let get_u64 = |doc_id: usize, field_id: u32| -> u64 {
+ let row = row_index.get_row(doc_id).unwrap();
+ row.get_by_field_id(field_id).unwrap().as_u64().unwrap()
+ };
+
+ assert_eq!(get_u64(0, col1_field.field_id()), 1_000);
+ assert_eq!(get_u64(0, col2_field.field_id()), 2_000);
+
+ if force_disjunct_segment_sort_values {
+ assert_eq!(get_u64(6, col1_field.field_id()), 2u64);
+ assert_eq!(get_u64(6, col2_field.field_id()), 4u64);
+
+ assert_eq!(get_u64(5, col1_field.field_id()), 3u64);
+ assert_eq!(get_u64(5, col2_field.field_id()), 6u64);
+
+ assert_eq!(get_u64(4, col1_field.field_id()), 10u64);
+ assert_eq!(get_u64(4, col2_field.field_id()), 20u64);
+
+ assert_eq!(get_u64(3, col1_field.field_id()), 20u64);
+ assert_eq!(get_u64(3, col2_field.field_id()), 40u64);
+ } else {
+ assert_eq!(get_u64(6, col1_field.field_id()), 1u64);
+ assert_eq!(get_u64(6, col2_field.field_id()), 2u64);
+
+ assert_eq!(get_u64(5, col1_field.field_id()), 2u64);
+ assert_eq!(get_u64(5, col2_field.field_id()), 4u64);
+
+ assert_eq!(get_u64(4, col1_field.field_id()), 3u64);
+ assert_eq!(get_u64(4, col2_field.field_id()), 6u64);
+
+ assert_eq!(get_u64(3, col1_field.field_id()), 5u64);
+ assert_eq!(get_u64(3, col2_field.field_id()), 10u64);
+ }
+ }
}
#[test]
@@ -332,6 +392,76 @@ mod tests {
postings.positions(&mut output);
assert_eq!(output, vec![1]);
}
+
+ {
+ let col1_field = index.schema().get_field("col1").unwrap();
+ let col2_field = index.schema().get_field("col2").unwrap();
+
+ let row_index = segment_reader.row_fields().row_index();
+ let row = row_index.get_row(0).unwrap();
+ assert_eq!(
+ row.get_by_field_id(col1_field.field_id())
+ .unwrap()
+ .as_u64()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(
+ row.get_by_field_id(col2_field.field_id())
+ .unwrap()
+ .as_u64()
+ .unwrap(),
+ 2
+ );
+
+ let row = row_index.get_row(1).unwrap();
+ assert_eq!(
+ row.get_by_field_id(col1_field.field_id())
+ .unwrap()
+ .as_u64()
+ .unwrap(),
+ 3
+ );
+ assert_eq!(
+ row.get_by_field_id(col2_field.field_id())
+ .unwrap()
+ .as_u64()
+ .unwrap(),
+ 6
+ );
+
+ let row = row_index.get_row(2).unwrap();
+ assert_eq!(
+ row.get_by_field_id(col1_field.field_id())
+ .unwrap()
+ .as_u64()
+ .unwrap(),
+ 1
+ );
+ assert_eq!(
+ row.get_by_field_id(col2_field.field_id())
+ .unwrap()
+ .as_u64()
+ .unwrap(),
+ 2
+ );
+
+ let row = row_index.get_row(3).unwrap();
+ assert_eq!(
+ row.get_by_field_id(col1_field.field_id())
+ .unwrap()
+ .as_u64()
+ .unwrap(),
+ 2
+ );
+ assert_eq!(
+ row.get_by_field_id(col2_field.field_id())
+ .unwrap()
+ .as_u64()
+ .unwrap(),
+ 4
+ );
+ }
}
// #[test]
diff --git a/crates/tantivy/src/indexer/segment_serializer.rs b/crates/tantivy/src/indexer/segment_serializer.rs
index 2edf1d3f..88431bf6 100644
--- a/crates/tantivy/src/indexer/segment_serializer.rs
+++ b/crates/tantivy/src/indexer/segment_serializer.rs
@@ -12,6 +12,7 @@ pub struct SegmentSerializer {
segment: Segment,
pub(crate) store_writer: StoreWriter,
column_field_write: WritePtr,
+ row_field_write: WritePtr,
fieldnorms_serializer: Option<FieldNormsSerializer>,
postings_serializer: InvertedIndexSerializer,
}
@@ -49,6 +50,7 @@ impl SegmentSerializer {
};
let column_field_write = segment.open_write(SegmentComponent::ColumnFields)?;
+ let row_field_write = segment.open_write(SegmentComponent::RowFields)?;
let fieldnorms_write = segment.open_write(SegmentComponent::FieldNorms)?;
let fieldnorms_serializer = FieldNormsSerializer::from_write(fieldnorms_write)?;
@@ -58,6 +60,7 @@ impl SegmentSerializer {
segment,
store_writer,
column_field_write,
+ row_field_write,
fieldnorms_serializer: Some(fieldnorms_serializer),
postings_serializer,
})
@@ -86,6 +89,11 @@ impl SegmentSerializer {
&mut self.column_field_write
}
+ /// Accessor to the `RowFieldSerializer`.
+ pub fn get_row_field_write(&mut self) -> &mut WritePtr {
+ &mut self.row_field_write
+ }
+
/// Extract the field norm serializer.
///
/// Note the fieldnorms serializer can only be extracted once.
@@ -104,6 +112,7 @@ impl SegmentSerializer {
fieldnorms_serializer.close()?;
}
self.column_field_write.terminate()?;
+ self.row_field_write.terminate()?;
self.postings_serializer.close()?;
self.store_writer.close()?;
Ok(())
diff --git a/crates/tantivy/src/indexer/segment_writer.rs b/crates/tantivy/src/indexer/segment_writer.rs
index ae004771..5cde9059 100644
--- a/crates/tantivy/src/indexer/segment_writer.rs
+++ b/crates/tantivy/src/indexer/segment_writer.rs
@@ -1,5 +1,6 @@
use crate::columnar::MonotonicallyMappableToU64;
use crate::common::JsonPathWriter;
+use crate::roworder::writer::RowFieldsWriter;
use crate::tokenizer_api::BoxTokenStream;
use itertools::Itertools;
@@ -66,6 +67,7 @@ pub struct SegmentWriter {
pub(crate) per_field_postings_writers: PerFieldPostingsWriter,
pub(crate) segment_serializer: SegmentSerializer,
pub(crate) column_field_writers: ColumnFieldsWriter,
+ pub(crate) row_field_writers: RowFieldsWriter,
pub(crate) fieldnorms_writer: FieldNormsWriter,
pub(crate) json_path_writer: JsonPathWriter,
pub(crate) json_positions_per_path: IndexingPositionsPerPath,
@@ -126,6 +128,7 @@ impl SegmentWriter {
&schema,
tokenizer_manager_column_field,
)?,
+ row_field_writers: RowFieldsWriter::from_schema(&schema)?,
doc_opstamps: Vec::with_capacity(1_000),
per_field_text_analyzers,
term_buffer: Term::with_capacity(16),
@@ -148,12 +151,18 @@ impl SegmentWriter {
.clone()
.map(|sort_by_field| get_doc_id_mapping_from_field(sort_by_field, &self))
.transpose()?;
+
+ let writers = Writers {
+ per_field_postings_writers: self.per_field_postings_writers,
+ column_field_writers: self.column_field_writers,
+ row_field_writers: self.row_field_writers,
+ fieldnorms_writer: self.fieldnorms_writer,
+ };
+
remap_and_write(
self.schema,
- &self.per_field_postings_writers,
self.ctx,
- self.column_field_writers,
- &self.fieldnorms_writer,
+ writers,
self.segment_serializer,
mapping.as_ref(),
)?;
@@ -167,6 +176,7 @@ impl SegmentWriter {
self.ctx.mem_usage()
+ self.fieldnorms_writer.mem_usage()
+ self.column_field_writers.mem_usage()
+ + self.row_field_writers.mem_usage()
+ self.segment_serializer.mem_usage()
}
@@ -362,6 +372,7 @@ impl SegmentWriter {
let AddOperation { document, opstamp } = add_operation;
self.doc_opstamps.push(opstamp);
self.column_field_writers.add_document(&document)?;
+ self.row_field_writers.add_document(&document)?;
self.index_document(&document)?;
let doc_writer = self.segment_serializer.get_store_writer();
doc_writer.store(&document, &self.schema)?;
@@ -390,6 +401,13 @@ impl SegmentWriter {
}
}
+struct Writers {
+ per_field_postings_writers: PerFieldPostingsWriter,
+ column_field_writers: ColumnFieldsWriter,
+ row_field_writers: RowFieldsWriter,
+ fieldnorms_writer: FieldNormsWriter,
+}
+
/// This method is used as a trick to workaround the borrow checker
/// Writes a view of a segment by pushing information
/// to the `SegmentSerializer`.
@@ -397,16 +415,16 @@ impl SegmentWriter {
/// `doc_id_map` is used to map to the new doc_id order.
fn remap_and_write(
schema: Schema,
- per_field_postings_writers: &PerFieldPostingsWriter,
ctx: IndexingContext,
- column_field_writers: ColumnFieldsWriter,
- fieldnorms_writer: &FieldNormsWriter,
+ writers: Writers,
mut serializer: SegmentSerializer,
doc_id_map: Option<&DocIdMapping>,
) -> crate::Result<()> {
debug!("remap-and-write");
if let Some(fieldnorms_serializer) = serializer.extract_fieldnorms_serializer() {
- fieldnorms_writer.serialize(fieldnorms_serializer, doc_id_map)?;
+ writers
+ .fieldnorms_writer
+ .serialize(fieldnorms_serializer, doc_id_map)?;
}
let fieldnorm_data = serializer
.segment()
@@ -415,13 +433,20 @@ fn remap_and_write(
serialize_postings(
ctx,
schema,
- per_field_postings_writers,
+ &writers.per_field_postings_writers,
fieldnorm_readers,
doc_id_map,
serializer.get_postings_serializer(),
)?;
debug!("columnfield-serialize");
- column_field_writers.serialize(serializer.get_column_field_write(), doc_id_map)?;
+ writers
+ .column_field_writers
+ .serialize(serializer.get_column_field_write(), doc_id_map)?;
+
+ debug!("rowfield-serialize");
+ writers
+ .row_field_writers
+ .serialize(serializer.get_row_field_write(), doc_id_map)?;
// finalize temp docstore and create version, which reflects the doc_id_map
if let Some(doc_id_map) = doc_id_map {
@@ -471,7 +496,7 @@ mod tests {
use crate::query::{PhraseQuery, QueryParser};
use crate::schema::{
Document, IndexRecordOption, OwnedValue, Schema, TextFieldIndexing, TextOptions, Value,
- STORED, STRING, TEXT,
+ INDEXED, ROW_ORDER, STORED, STRING, TEXT,
};
use crate::store::{Compressor, StoreReader, StoreWriter};
use crate::time::format_description::well_known::Rfc3339;
@@ -1050,4 +1075,29 @@ mod tests {
"Schema error: 'Error getting tokenizer for field: title'"
);
}
+
+ #[test]
+ fn test_row_order_indexing() {
+ let mut schema_builder = Schema::builder();
+
+ let text_field = schema_builder.add_text_field("text", TEXT);
+ let u64_field = schema_builder.add_u64_field("u64", STORED | ROW_ORDER | INDEXED);
+ let f64_field = schema_builder.add_f64_field("f64", STORED | ROW_ORDER | INDEXED);
+
+ let schema = schema_builder.build();
+ let index = Index::create_in_ram(schema.clone());
+ let mut writer = index.writer_for_tests().unwrap();
+
+ let doc = doc!(text_field=>"hello", u64_field=>10u64, f64_field=>10.0f64);
+ writer.add_document(doc).unwrap();
+ writer.commit().unwrap();
+
+ let reader = index.reader().unwrap();
+ let searcher = reader.searcher();
+ let segment_reader = searcher.segment_reader(0);
+ let row = segment_reader.row_fields().row_index().get_row(0).unwrap();
+
+ assert_eq!(row.get_u64(&u64_field), Some(10u64));
+ assert_eq!(row.get_f64(&f64_field), Some(10.0f64));
+ }
}
diff --git a/crates/tantivy/src/lib.rs b/crates/tantivy/src/lib.rs
index b4e6883e..62d992d2 100644
--- a/crates/tantivy/src/lib.rs
+++ b/crates/tantivy/src/lib.rs
@@ -114,6 +114,7 @@ pub mod fieldnorm;
pub mod index;
pub mod positions;
pub mod postings;
+pub mod roworder;
/// Module containing the different query implementations.
pub mod query;
diff --git a/crates/tantivy/src/roworder/mod.rs b/crates/tantivy/src/roworder/mod.rs
new file mode 100644
index 00000000..a14f66a1
--- /dev/null
+++ b/crates/tantivy/src/roworder/mod.rs
@@ -0,0 +1,925 @@
+use core::fmt;
+use std::{
+ borrow::Borrow,
+ io::{self, BufWriter, Write},
+};
+
+use ownedbytes::OwnedBytes;
+use strum::EnumDiscriminants;
+use thiserror::Error;
+
+pub mod readers;
+pub mod writer;
+
+#[derive(Debug, Error)]
+pub enum RowOrderError {
+ #[error("Error occurred during IO operation: {0}")]
+ Io(#[from] io::Error),
+}
+
+type Result<T, E = RowOrderError> = std::result::Result<T, E>;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Field {
+ name: String,
+ id: u32,
+ typ: RowValueType,
+}
+
+impl Field {
+ pub fn new(name: String, id: u32, typ: RowValueType) -> Self {
+ Self { name, id, typ }
+ }
+
+ pub fn row_value_type(&self) -> RowValueType {
+ self.typ
+ }
+
+ pub fn id(&self) -> u32 {
+ self.id
+ }
+
+ fn write_to(&self, buf: &mut Vec<u8>) {
+ buf.clear();
+ let serialized_name = self.name.as_bytes();
+ let len = serialized_name.len() as u32;
+ let serialized_len = len.to_le_bytes();
+ let serialized_id = self.id.to_le_bytes();
+ let serialized_typ = self.typ.id().to_le_bytes();
+
+ let total_bytes = serialized_name.len()
+ + serialized_len.len()
+ + serialized_id.len()
+ + serialized_typ.len();
+
+ buf.resize(total_bytes, 0);
+
+ let mut offset = 0;
+ buf[offset..offset + serialized_len.len()].copy_from_slice(&serialized_len);
+ offset += serialized_len.len();
+ buf[offset..offset + serialized_name.len()].copy_from_slice(serialized_name);
+ offset += serialized_name.len();
+ buf[offset..offset + serialized_id.len()].copy_from_slice(&serialized_id);
+ offset += serialized_id.len();
+ buf[offset..offset + serialized_typ.len()].copy_from_slice(&serialized_typ);
+ }
+
+ fn read_from(bytes: &[u8]) -> Result<(Self, usize)> {
+ let len = u32::from_le_bytes(bytes[..4].try_into().unwrap()) as usize;
+ let name = String::from_utf8(bytes[4..4 + len].to_vec()).unwrap();
+ let id = u32::from_le_bytes(bytes[4 + len..8 + len].try_into().unwrap());
+ let typ = RowValueType::from_id(u32::from_le_bytes(
+ bytes[8 + len..12 + len].try_into().unwrap(),
+ ));
+
+ Ok((Self { name, id, typ }, 12 + len))
+ }
+}
+
+struct Header {
+ field_order: Vec<Field>,
+ row_size_bytes: usize,
+}
+
+impl Header {
+ fn row_types(&self) -> impl Iterator<Item = RowValueType> + '_ {
+ self.field_order.iter().map(|field| field.row_value_type())
+ }
+
+ fn serialize(&self) -> Vec<u8> {
+ let mut res = Vec::new();
+ let mut buf = Vec::new();
+
+ res.extend_from_slice(&(self.row_size_bytes as u32).to_le_bytes());
+
+ for field in &self.field_order {
+ field.write_to(&mut buf);
+ res.extend_from_slice(&buf);
+ }
+
+ res
+ }
+
+ fn deserialize(bytes: &[u8]) -> Result<Self> {
+ let row_size_bytes = u32::from_le_bytes(bytes[..4].try_into().unwrap()) as usize;
+ let mut offset = 4;
+ let mut field_order = Vec::new();
+
+ while offset < bytes.len() {
+ let (field, bytes_read) = Field::read_from(&bytes[offset..])?;
+ field_order.push(field);
+ offset += bytes_read;
+ }
+
+ Ok(Self {
+ field_order,
+ row_size_bytes,
+ })
+ }
+
+ fn row_index(&self) -> Vec<Option<usize>> {
+ if self.field_order.is_empty() {
+ return vec![];
+ }
+
+ let max_id = self
+ .field_order
+ .iter()
+ .map(|field| field.id())
+ .max()
+ .unwrap();
+
+ let mut res = vec![None; max_id as usize + 1];
+
+ for (idx, field) in self.field_order.iter().enumerate() {
+ res[field.id() as usize] = Some(idx);
+ }
+
+ res
+ }
+
+ fn field_order(&self) -> &[Field] {
+ &self.field_order
+ }
+
+ fn row_size_bytes(&self) -> usize {
+ self.row_size_bytes
+ }
+}
+
+#[derive(EnumDiscriminants, Debug, Clone, Copy, PartialEq)]
+#[strum_discriminants(name(RowValueType))]
+pub enum RowValue {
+ U64(u64),
+ I64(i64),
+ F64(f64),
+ Bool(bool),
+}
+
+impl RowValueType {
+ const fn size(&self) -> usize {
+ match self {
+ RowValueType::U64 => 8,
+ RowValueType::F64 => 8,
+ RowValueType::I64 => 8,
+ RowValueType::Bool => 1,
+ }
+ }
+
+ fn id(&self) -> u32 {
+ match self {
+ RowValueType::U64 => 0,
+ RowValueType::F64 => 1,
+ RowValueType::I64 => 2,
+ RowValueType::Bool => 3,
+ }
+ }
+
+ fn from_id(id: u32) -> Self {
+ match id {
+ 0 => RowValueType::U64,
+ 1 => RowValueType::F64,
+ 2 => RowValueType::I64,
+ 3 => RowValueType::Bool,
+ _ => panic!("Invalid id"),
+ }
+ }
+}
+
+impl RowValue {
+ fn write_to(&self, buf: &mut [u8]) {
+ match self {
+ RowValue::U64(v) => {
+ buf.copy_from_slice(&v.to_le_bytes());
+ }
+ RowValue::F64(v) => {
+ buf.copy_from_slice(&v.to_le_bytes());
+ }
+ RowValue::I64(v) => {
+ buf.copy_from_slice(&v.to_le_bytes());
+ }
+ RowValue::Bool(v) => {
+ buf[0] = *v as u8;
+ }
+ }
+ }
+
+ fn read_from(buf: &[u8], typ: RowValueType) -> Self {
+ match typ {
+ RowValueType::U64 => {
+ let mut bytes = [0u8; 8];
+ bytes.copy_from_slice(&buf[..typ.size()]);
+ RowValue::U64(u64::from_le_bytes(bytes))
+ }
+ RowValueType::F64 => {
+ let mut bytes = [0u8; 8];
+ bytes.copy_from_slice(&buf[..typ.size()]);
+ RowValue::F64(f64::from_le_bytes(bytes))
+ }
+ RowValueType::I64 => {
+ let mut bytes = [0u8; 8];
+ bytes.copy_from_slice(&buf[..typ.size()]);
+ RowValue::I64(i64::from_le_bytes(bytes))
+ }
+
+ RowValueType::Bool => RowValue::Bool(buf[0] != 0),
+ }
+ }
+
+ pub fn as_u64(&self) -> Option<u64> {
+ match self {
+ RowValue::U64(v) => Some(*v),
+ _ => None,
+ }
+ }
+
+ pub fn as_i64(&self) -> Option<i64> {
+ match self {
+ RowValue::I64(v) => Some(*v),
+ _ => None,
+ }
+ }
+
+ pub fn as_f64(&self) -> Option<f64> {
+ match self {
+ RowValue::F64(v) => Some(*v),
+ _ => None,
+ }
+ }
+
+ pub fn as_bool(&self) -> Option<bool> {
+ match self {
+ RowValue::Bool(v) => Some(*v),
+ _ => None,
+ }
+ }
+}
+
+pub struct Row<'a> {
+ index: &'a [Option<usize>],
+ values: Vec<RowValue>,
+}
+
+impl<'a> fmt::Debug for Row<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("Row").field("values", &self.values).finish()
+ }
+}
+
+pub trait AsFieldId {
+ fn field_id(&self) -> u32;
+}
+
+impl AsFieldId for Field {
+ fn field_id(&self) -> u32 {
+ self.id()
+ }
+}
+
+impl AsFieldId for crate::schema::Field {
+ fn field_id(&self) -> u32 {
+ crate::schema::Field::field_id(*self)
+ }
+}
+
+impl<'a> Row<'a> {
+ pub fn get<F: AsFieldId>(&self, field: &F) -> Option<&RowValue> {
+ self.get_by_field_id(field.field_id())
+ }
+
+ pub fn get_by_field_id(&self, field_id: u32) -> Option<&RowValue> {
+ self.index
+ .get(field_id as usize)
+ .copied()
+ .flatten()
+ .map(|idx| &self.values[idx])
+ }
+
+ pub fn get_u64<F: AsFieldId>(&self, field: &F) -> Option<u64> {
+ self.get(field).and_then(|v| v.as_u64())
+ }
+
+ pub fn get_i64<F: AsFieldId>(&self, field: &F) -> Option<i64> {
+ self.get(field).and_then(|v| v.as_i64())
+ }
+
+ pub fn get_f64<F: AsFieldId>(&self, field: &F) -> Option<f64> {
+ self.get(field).and_then(|v| v.as_f64())
+ }
+
+ pub fn get_bool<F: AsFieldId>(&self, field: &F) -> Option<bool> {
+ self.get(field).and_then(|v| v.as_bool())
+ }
+}
+
+pub struct RowIndexer<W: Write> {
+ header: Header,
+ writer: BufWriter<W>,
+ buf: Vec<u8>,
+}
+
+impl<W> RowIndexer<W>
+where
+ W: Write,
+{
+ pub fn new(writer: W, field_order: Vec<Field>) -> io::Result<Self> {
+ let row_size_bytes = field_order
+ .iter()
+ .map(|field| field.row_value_type().size())
+ .sum();
+
+ let header = Header {
+ field_order,
+ row_size_bytes,
+ };
+
+ let mut writer = BufWriter::new(writer);
+
+ let serialized_header = header.serialize();
+ let len = (serialized_header.len() as u64).to_le_bytes();
+ writer.write_all(&len)?;
+ writer.write_all(&serialized_header)?;
+ writer.flush()?;
+
+ Ok(Self {
+ header,
+ writer,
+ buf: vec![0; row_size_bytes],
+ })
+ }
+
+ pub fn write_row(&mut self, values: &[RowValue]) {
+ debug_assert_eq!(
+ values.len(),
+ self.header.field_order.len(),
+ "Row has wrong number of values"
+ );
+
+ debug_assert_eq!(
+ values
+ .iter()
+ .map(|v| RowValueType::from(v).size())
+ .sum::<usize>(),
+ self.header.row_size_bytes,
+ "Row has wrong size"
+ );
+
+ self.buf.clear();
+ self.buf.resize(self.header.row_size_bytes, 0);
+
+ let mut prev_end = 0;
+
+ for (value, typ) in values.iter().zip(self.header.row_types()) {
+ value.write_to(&mut self.buf[prev_end..prev_end + typ.size()]);
+ prev_end += typ.size();
+ }
+
+ self.writer.write_all(&self.buf).unwrap();
+ }
+
+ pub fn finish(mut self) -> io::Result<W> {
+ self.writer.flush()?;
+
+ match self.writer.into_inner() {
+ Ok(w) => Ok(w),
+ Err(_) => unreachable!("Failed to unwrap writer into inner value"),
+ }
+ }
+}
+
+pub struct RowIndex {
+ header: Header,
+ index: Vec<Option<usize>>,
+ body: OwnedBytes,
+}
+
+impl RowIndex {
+ pub fn open(bytes: OwnedBytes) -> Result<Self> {
+ if bytes.is_empty() {
+ return Ok(Self {
+ header: Header {
+ field_order: vec![],
+ row_size_bytes: 0,
+ },
+ index: vec![],
+ body: bytes,
+ });
+ }
+
+ let num_header_bytes = u64::from_le_bytes(bytes[..8].try_into().unwrap()) as usize;
+ let serialized_header = &bytes[8..8 + num_header_bytes];
+ let header = Header::deserialize(serialized_header)?;
+ let num_bytes = bytes.len();
+ let body = bytes.slice(8 + num_header_bytes..num_bytes);
+
+ let index = header.row_index();
+
+ Ok(Self {
+ header,
+ index,
+ body,
+ })
+ }
+
+ pub fn get_row(&self, idx: usize) -> Option<Row<'_>> {
+ if self.header.field_order().is_empty() {
+ return None;
+ }
+
+ let start = idx * self.header.row_size_bytes();
+ let end = start + self.header.row_size_bytes();
+
+ if end > self.body.len() {
+ return None;
+ }
+
+ let value_bytes = self.body.slice(start..end);
+ let mut values = Vec::new();
+ let mut offset = 0;
+
+ for field in self.header.field_order().iter() {
+ let typ = field.row_value_type();
+
+ if offset + typ.size() > value_bytes.len() {
+ return None;
+ }
+
+ let value = RowValue::read_from(&value_bytes[offset..offset + typ.size()], typ);
+ values.push(value);
+ offset += typ.size();
+ }
+
+ Some(Row {
+ index: &self.index,
+ values,
+ })
+ }
+
+ pub fn iter(&self) -> impl Iterator<Item = Row<'_>> + '_ {
+ (0..self.num_rows()).filter_map(move |idx| self.get_row(idx))
+ }
+
+ pub fn num_rows(&self) -> usize {
+ if self.body.is_empty() {
+ return 0;
+ }
+
+ debug_assert_eq!(
+ self.body.len() % self.header.row_size_bytes(),
+ 0,
+ "Length of body is not a multiple of row size"
+ );
+
+ self.body.len() / self.header.row_size_bytes()
+ }
+
+ pub fn field_by_id(&self, id: u32) -> Option<&Field> {
+ let idx = (*self.index.get(id as usize)?)?;
+ self.header.field_order.get(idx)
+ }
+
+ pub fn total_num_bytes_for_field(&self, field: &Field) -> usize {
+ field.row_value_type().size() * self.num_rows()
+ }
+
+ fn header(&self) -> &Header {
+ &self.header
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct MergeAddr {
+ pub segment_ord: usize,
+}
+
+#[derive(Debug, Clone)]
+pub enum MergeRowOrder {
+ Stack,
+ Shuffled { addrs: Vec<MergeAddr> },
+}
+
+pub fn merge<I, W>(indexes: &[I], order: MergeRowOrder, writer: W) -> Result<W>
+where
+ W: Write,
+ I: Borrow<RowIndex>,
+{
+ if indexes.is_empty() {
+ return Ok(writer);
+ }
+
+ let first = indexes[0].borrow();
+ debug_assert!(
+ indexes
+ .iter()
+ .all(|index| index.borrow().header().field_order() == first.header().field_order()),
+ "Indexes have different field orders"
+ );
+
+ debug_assert!(
+ indexes.iter().all(
+ |index| index.borrow().header().row_size_bytes() == first.header().row_size_bytes()
+ ),
+ "Indexes have different row sizes"
+ );
+
+ let mut writer = RowIndexer::new(writer, first.header().field_order().to_vec())?;
+
+ match order {
+ MergeRowOrder::Stack => {
+ for index in indexes {
+ for row in index.borrow().iter() {
+ writer.write_row(row.values.as_slice());
+ }
+ }
+ }
+ MergeRowOrder::Shuffled { addrs } => {
+ let mut iters: Vec<_> = indexes.iter().map(|index| index.borrow().iter()).collect();
+
+ for addr in addrs {
+ if let Some(row) = iters[addr.segment_ord].next() {
+ writer.write_row(row.values.as_slice())
+ }
+ }
+ }
+ }
+
+ Ok(writer.finish()?)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_row_value_ser() {
+ let mut buf = [0u8; 8];
+ let value = RowValue::U64(42);
+ value.write_to(&mut buf);
+ assert_eq!(RowValue::read_from(&buf, RowValueType::U64), value);
+
+ let value = RowValue::F64(42.0);
+ value.write_to(&mut buf);
+ assert_eq!(RowValue::read_from(&buf, RowValueType::F64), value);
+ }
+
+ #[test]
+ fn test_field_ser() {
+ let field = Field::new("test".to_string(), 42, RowValueType::U64);
+ let mut buf = Vec::new();
+ field.write_to(&mut buf);
+ let (deserialized, _) = Field::read_from(&buf).unwrap();
+ assert_eq!(field, deserialized);
+ }
+
+ #[test]
+ fn test_row_index() {
+ let buf = Vec::new();
+
+ let mut indexer = RowIndexer::new(
+ buf,
+ vec![
+ Field::new("test".to_string(), 0, RowValueType::U64),
+ Field::new("test2".to_string(), 1, RowValueType::F64),
+ ],
+ )
+ .unwrap();
+
+ indexer.write_row(&[RowValue::U64(0), RowValue::F64(0.0)]);
+ indexer.write_row(&[RowValue::U64(1), RowValue::F64(0.0)]);
+ indexer.write_row(&[RowValue::U64(42), RowValue::F64(42.0)]);
+
+ let bytes = indexer.finish().unwrap();
+ let index = RowIndex::open(bytes.into()).unwrap();
+
+ let row = index.get_row(0).unwrap();
+ assert_eq!(row.get_by_field_id(0), Some(&RowValue::U64(0)));
+ assert_eq!(row.get_by_field_id(1), Some(&RowValue::F64(0.0)));
+
+ let row = index.get_row(1).unwrap();
+ assert_eq!(row.get_by_field_id(0), Some(&RowValue::U64(1)));
+ assert_eq!(row.get_by_field_id(1), Some(&RowValue::F64(0.0)));
+
+ let row = index.get_row(2).unwrap();
+ assert_eq!(row.get_by_field_id(0), Some(&RowValue::U64(42)));
+ assert_eq!(row.get_by_field_id(1), Some(&RowValue::F64(42.0)));
+
+ assert!(index.get_row(3).is_none());
+ }
+
+ #[test]
+ fn test_empty_row_index() {
+ let buf = Vec::new();
+
+ let indexer = RowIndexer::new(buf, vec![]).unwrap();
+ let bytes = indexer.finish().unwrap();
+ let index = RowIndex::open(bytes.into()).unwrap();
+
+ assert!(index.get_row(0).is_none());
+
+ let buf = Vec::new();
+ let indexer = RowIndexer::new(
+ buf,
+ vec![Field::new("test".to_string(), 0, RowValueType::U64)],
+ )
+ .unwrap();
+ let bytes = indexer.finish().unwrap();
+ let index = RowIndex::open(bytes.into()).unwrap();
+
+ assert!(index.get_row(0).is_none());
+ }
+
+ #[test]
+ fn test_iter() {
+ let buf = Vec::new();
+
+ let mut indexer = RowIndexer::new(
+ buf,
+ vec![
+ Field::new("a".to_string(), 0, RowValueType::U64),
+ Field::new("b".to_string(), 1, RowValueType::F64),
+ ],
+ )
+ .unwrap();
+
+ let rows = [
+ vec![RowValue::U64(0), RowValue::F64(0.0)],
+ vec![RowValue::U64(1), RowValue::F64(0.0)],
+ vec![RowValue::U64(42), RowValue::F64(42.0)],
+ ];
+
+ for row in rows.iter() {
+ indexer.write_row(row);
+ }
+
+ let bytes = indexer.finish().unwrap();
+ let index = RowIndex::open(bytes.into()).unwrap();
+
+ let stored_rows: Vec<_> = index.iter().collect();
+ assert_eq!(rows.len(), stored_rows.len());
+
+ for (expected, stored) in rows.iter().zip(stored_rows.iter()) {
+ assert_eq!(expected, &stored.values);
+ }
+ }
+
+ #[test]
+ fn test_empty_iter() {
+ let buf = Vec::new();
+
+ let indexer = RowIndexer::new(buf, vec![]).unwrap();
+ let bytes = indexer.finish().unwrap();
+ let index = RowIndex::open(bytes.into()).unwrap();
+
+ let rows: Vec<_> = index.iter().collect();
+ assert!(rows.is_empty());
+ }
+
+ #[test]
+ fn test_merge_stacked() {
+ let mut indexers = Vec::new();
+
+ for _ in 0..3 {
+ let buf = Vec::new();
+ let indexer = RowIndexer::new(
+ buf,
+ vec![
+ Field::new("a".to_string(), 0, RowValueType::U64),
+ Field::new("b".to_string(), 1, RowValueType::F64),
+ ],
+ )
+ .unwrap();
+
+ indexers.push(indexer);
+ }
+
+ let rows = [
+ vec![RowValue::U64(0), RowValue::F64(0.0)],
+ vec![RowValue::U64(1), RowValue::F64(0.0)],
+ vec![RowValue::U64(42), RowValue::F64(42.0)],
+ ];
+
+ let mut indexes = Vec::new();
+ for mut indexer in indexers {
+ for row in rows.iter() {
+ indexer.write_row(row);
+ }
+
+ let bytes = indexer.finish().unwrap();
+ let index = RowIndex::open(bytes.into()).unwrap();
+ indexes.push(index);
+ }
+
+ let buf = Vec::new();
+ let buf = merge(&indexes, MergeRowOrder::Stack, buf).unwrap();
+ let index = RowIndex::open(buf.into()).unwrap();
+
+ let stored_rows: Vec<_> = index.iter().collect();
+ assert_eq!(rows.len() * indexes.len(), stored_rows.len());
+
+ for (expected, stored) in rows
+ .iter()
+ .cycle()
+ .take(stored_rows.len())
+ .zip(stored_rows.iter())
+ {
+ assert_eq!(expected, &stored.values);
+ }
+ }
+
+ #[test]
+ fn test_merge_shuffled() {
+ let mut indexers = Vec::new();
+
+ for _ in 0..3 {
+ let buf = Vec::new();
+ let indexer = RowIndexer::new(
+ buf,
+ vec![
+ Field::new("a".to_string(), 0, RowValueType::U64),
+ Field::new("b".to_string(), 1, RowValueType::F64),
+ ],
+ )
+ .unwrap();
+
+ indexers.push(indexer);
+ }
+
+ let rows = [
+ vec![RowValue::U64(0), RowValue::F64(0.0)],
+ vec![RowValue::U64(1), RowValue::F64(0.0)],
+ vec![RowValue::U64(42), RowValue::F64(42.0)],
+ ];
+
+ let mut indexes = Vec::new();
+ for mut indexer in indexers {
+ for row in rows.iter() {
+ indexer.write_row(row);
+ }
+
+ let bytes = indexer.finish().unwrap();
+ let index = RowIndex::open(bytes.into()).unwrap();
+ indexes.push(index);
+ }
+
+ let buf = Vec::new();
+ let buf = merge(
+ &indexes,
+ MergeRowOrder::Shuffled {
+ addrs: (0..indexes.len())
+ .map(|i| MergeAddr { segment_ord: i })
+ .cycle()
+ .take(indexes.len() * rows.len())
+ .collect(),
+ },
+ buf,
+ )
+ .unwrap();
+ let index = RowIndex::open(buf.into()).unwrap();
+
+ let stored_rows: Vec<_> = index.iter().collect();
+ assert_eq!(rows.len() * indexes.len(), stored_rows.len());
+
+ stored_rows
+ .chunks(indexes.len())
+ .enumerate()
+ .for_each(|(i, chunk)| {
+ let row = &rows[i];
+
+ for c in chunk {
+ assert_eq!(row, &c.values);
+ }
+ });
+ }
+
+ #[test]
+ fn test_merge_shuffled_diff_len() {
+ let mut indexers = Vec::new();
+
+ for _ in 0..2 {
+ let buf = Vec::new();
+ let indexer = RowIndexer::new(
+ buf,
+ vec![
+ Field::new("a".to_string(), 0, RowValueType::U64),
+ Field::new("b".to_string(), 1, RowValueType::F64),
+ ],
+ )
+ .unwrap();
+
+ indexers.push(indexer);
+ }
+
+ indexers[0].write_row(&[RowValue::U64(0), RowValue::F64(0.0)]);
+ indexers[0].write_row(&[RowValue::U64(1), RowValue::F64(0.0)]);
+ indexers[1].write_row(&[RowValue::U64(42), RowValue::F64(42.0)]);
+
+ let mut indexes = Vec::new();
+ for indexer in indexers {
+ let bytes = indexer.finish().unwrap();
+ let index = RowIndex::open(bytes.into()).unwrap();
+ indexes.push(index);
+ }
+
+ let order = MergeRowOrder::Shuffled {
+ addrs: vec![
+ MergeAddr { segment_ord: 0 },
+ MergeAddr { segment_ord: 1 },
+ MergeAddr { segment_ord: 0 },
+ ],
+ };
+ let buf = Vec::new();
+
+ let buf = merge(&indexes, order, buf).unwrap();
+ let index = RowIndex::open(buf.into()).unwrap();
+
+ let stored_rows: Vec<_> = index.iter().collect();
+ assert_eq!(stored_rows.len(), 3);
+
+ let rows = [
+ vec![RowValue::U64(0), RowValue::F64(0.0)],
+ vec![RowValue::U64(42), RowValue::F64(42.0)],
+ vec![RowValue::U64(1), RowValue::F64(0.0)],
+ ];
+
+ for (expected, stored) in rows.iter().zip(stored_rows.iter()) {
+ assert_eq!(expected, &stored.values);
+ }
+ }
+
+ #[test]
+ fn test_merge_empty() {
+ let buf = Vec::new();
+ let buf = merge(&[] as &[RowIndex], MergeRowOrder::Stack, buf).unwrap();
+ let index = RowIndex::open(buf.into()).unwrap();
+
+ assert_eq!(index.num_rows(), 0);
+
+ let buf = Vec::new();
+ let buf = merge(
+ &[] as &[RowIndex],
+ MergeRowOrder::Shuffled { addrs: vec![] },
+ buf,
+ )
+ .unwrap();
+ let index = RowIndex::open(buf.into()).unwrap();
+
+ assert_eq!(index.num_rows(), 0);
+
+ let a = RowIndexer::new(Vec::new(), vec![])
+ .unwrap()
+ .finish()
+ .unwrap();
+ let b = RowIndexer::new(Vec::new(), vec![])
+ .unwrap()
+ .finish()
+ .unwrap();
+
+ let buf = merge(
+ &[
+ RowIndex::open(a.into()).unwrap(),
+ RowIndex::open(b.into()).unwrap(),
+ ],
+ MergeRowOrder::Stack,
+ Vec::new(),
+ )
+ .unwrap();
+
+ let index = RowIndex::open(buf.into()).unwrap();
+ assert_eq!(index.num_rows(), 0);
+
+ let a = RowIndexer::new(
+ Vec::new(),
+ vec![
+ Field::new("a".to_string(), 0, RowValueType::U64),
+ Field::new("b".to_string(), 1, RowValueType::F64),
+ ],
+ )
+ .unwrap()
+ .finish()
+ .unwrap();
+
+ let b = RowIndexer::new(
+ Vec::new(),
+ vec![
+ Field::new("a".to_string(), 0, RowValueType::U64),
+ Field::new("b".to_string(), 1, RowValueType::F64),
+ ],
+ )
+ .unwrap()
+ .finish()
+ .unwrap();
+
+ let buf = merge(
+ &[
+ RowIndex::open(a.into()).unwrap(),
+ RowIndex::open(b.into()).unwrap(),
+ ],
+ MergeRowOrder::Stack,
+ Vec::new(),
+ )
+ .unwrap();
+
+ let index = RowIndex::open(buf.into()).unwrap();
+ assert_eq!(index.num_rows(), 0);
+ }
+}
diff --git a/crates/tantivy/src/roworder/readers.rs b/crates/tantivy/src/roworder/readers.rs
new file mode 100644
index 00000000..630ba514
--- /dev/null
+++ b/crates/tantivy/src/roworder/readers.rs
@@ -0,0 +1,45 @@
+use std::io;
+use std::sync::Arc;
+
+use crate::common::file_slice::FileSlice;
+use crate::schema::Schema;
+use crate::space_usage::{FieldUsage, PerFieldSpaceUsage};
+use crate::{Result, TantivyError};
+
+use super::RowIndex;
+
+#[derive(Clone)]
+pub struct RowFieldReaders {
+ index: Arc<RowIndex>,
+}
+
+impl RowFieldReaders {
+ pub fn open(slice: FileSlice) -> Result<Self> {
+ Ok(Self {
+ index: Arc::new(RowIndex::open(slice.read_bytes()?).map_err(|_| {
+ TantivyError::InternalError("Row order index failed to open".to_string())
+ })?),
+ })
+ }
+
+ pub fn space_usage(&self, schema: &Schema) -> io::Result<PerFieldSpaceUsage> {
+ let mut per_field_usages: Vec<FieldUsage> = Default::default();
+ for (field, field_entry) in schema.fields() {
+ if field_entry.is_row_order() {
+ let mut field_usage = FieldUsage::empty(field);
+
+ if let Some(field) = self.index.field_by_id(field.field_id()) {
+ let num_bytes = self.index.total_num_bytes_for_field(field).into();
+ field_usage.add_field_idx(0, num_bytes);
+ }
+
+ per_field_usages.push(field_usage);
+ }
+ }
+ Ok(PerFieldSpaceUsage::new(per_field_usages))
+ }
+
+ pub fn row_index(&self) -> &RowIndex {
+ &self.index
+ }
+}
diff --git a/crates/tantivy/src/roworder/writer.rs b/crates/tantivy/src/roworder/writer.rs
new file mode 100644
index 00000000..df4100bf
--- /dev/null
+++ b/crates/tantivy/src/roworder/writer.rs
@@ -0,0 +1,161 @@
+use std::{collections::BTreeMap, io};
+
+use crate::{
+ indexer::doc_id_mapping::DocIdMapping,
+ roworder::RowIndexer,
+ schema::{
+ document::{ReferenceValue, ReferenceValueLeaf},
+ Schema, Value,
+ },
+};
+
+use super::{Field, RowValue, RowValueType};
+
+struct Row {
+ values: Vec<RowValue>,
+}
+
+impl TryFrom<(crate::schema::Field, &crate::schema::FieldEntry)> for Field {
+ type Error = crate::TantivyError;
+
+ fn try_from(
+ (field, entry): (crate::schema::Field, &crate::schema::FieldEntry),
+ ) -> Result<Self, Self::Error> {
+ let name = entry.name().to_string();
+ let id = field.field_id();
+
+ let value_type = match entry.field_type() {
+ crate::schema::FieldType::U64(_) => RowValueType::U64,
+ crate::schema::FieldType::I64(_) => RowValueType::I64,
+ crate::schema::FieldType::F64(_) => RowValueType::F64,
+ crate::schema::FieldType::Bool(_) => RowValueType::Bool,
+ crate::schema::FieldType::Str(_)
+ | crate::schema::FieldType::Date(_)
+ | crate::schema::FieldType::Bytes(_)
+ | crate::schema::FieldType::JsonObject(_)
+ | crate::schema::FieldType::IpAddr(_) => {
+ return Err(crate::TantivyError::SchemaError(format!(
+ "Field {:?} is not supported in row order",
+ entry
+ )))
+ }
+ };
+
+ Ok(Field::new(name, id, value_type))
+ }
+}
+
+pub struct RowFieldsWriter {
+ fields: Vec<Field>,
+ rows: Vec<Row>,
+ mem_usage: usize,
+
+ field_ids: Vec<bool>,
+}
+
+impl RowFieldsWriter {
+ pub fn from_schema(schema: &Schema) -> crate::Result<Self> {
+ let mut fields = Vec::new();
+
+ for (field, entry) in schema.fields().filter(|(_, entry)| entry.is_row_order()) {
+ let field = Field::try_from((field, entry))?;
+ fields.push(field);
+ }
+ let max_field_id = fields.iter().map(|field| field.id).max().unwrap_or(0);
+ let mut field_ids = vec![false; max_field_id as usize + 1];
+ for field in &fields {
+ field_ids[field.id as usize] = true;
+ }
+
+ Ok(Self {
+ fields,
+ rows: Vec::new(),
+ mem_usage: 0,
+ field_ids,
+ })
+ }
+
+ pub fn mem_usage(&self) -> usize {
+ self.mem_usage
+ }
+
+ pub fn add_document<D>(&mut self, doc: &D) -> crate::Result<()>
+ where
+ D: crate::Document,
+ {
+ let mut buf = BTreeMap::new();
+
+ for (field, value) in doc.iter_fields_and_values().filter(|(field, _)| {
+ self.field_ids
+ .get(field.field_id() as usize)
+ .copied()
+ .unwrap_or(false)
+ }) {
+ let value_access = value as D::Value<'_>;
+
+ match value_access.as_value() {
+ ReferenceValue::Leaf(leaf) => match leaf {
+ ReferenceValueLeaf::Null
+ | ReferenceValueLeaf::Str(_)
+ | ReferenceValueLeaf::Date(_)
+ | ReferenceValueLeaf::Bytes(_)
+ | ReferenceValueLeaf::IpAddr(_)
+ | ReferenceValueLeaf::PreTokStr(_) => {}
+
+ ReferenceValueLeaf::U64(val) => {
+ buf.insert(field.field_id(), RowValue::U64(val));
+ }
+ ReferenceValueLeaf::I64(val) => {
+ buf.insert(field.field_id(), RowValue::I64(val));
+ }
+ ReferenceValueLeaf::F64(val) => {
+ buf.insert(field.field_id(), RowValue::F64(val));
+ }
+ ReferenceValueLeaf::Bool(val) => {
+ buf.insert(field.field_id(), RowValue::Bool(val));
+ }
+ },
+ ReferenceValue::Array(_) => {
+ unimplemented!("Array values are not supported in row order")
+ }
+ ReferenceValue::Object(_) => {
+ unimplemented!("Json values are not supported in row order")
+ }
+ }
+ }
+
+ let row = Row {
+ values: buf.into_values().collect(),
+ };
+
+ self.rows.push(row);
+
+ Ok(())
+ }
+
+ pub fn serialize(
+ self,
+ wrt: &mut dyn io::Write,
+ doc_id_map_opt: Option<&DocIdMapping>,
+ ) -> io::Result<()> {
+ let mut indexer = RowIndexer::new(wrt, self.fields)?;
+
+ match doc_id_map_opt {
+ Some(doc_id_map) => {
+ for old_id in doc_id_map.iter_old_doc_ids() {
+ let row = &self.rows[old_id as usize];
+ indexer.write_row(&row.values);
+ }
+ }
+ None => {
+ for row in self.rows {
+ indexer.write_row(&row.values);
+ }
+ }
+ }
+
+ indexer.finish()?;
+
+ Ok(())
+ }
+}
diff --git a/crates/tantivy/src/schema/field_entry.rs b/crates/tantivy/src/schema/field_entry.rs
index 721a8936..8d73d772 100644
--- a/crates/tantivy/src/schema/field_entry.rs
+++ b/crates/tantivy/src/schema/field_entry.rs
@@ -102,6 +102,11 @@ impl FieldEntry {
self.field_type.is_columnar()
}
+ /// Returns true if the field is a row ordered field
+ pub fn is_row_order(&self) -> bool {
+ self.field_type.is_row_order()
+ }
+
/// Returns true if the field has the expand dots option set (for json fields)
pub fn is_expand_dots_enabled(&self) -> bool {
match self.field_type {
diff --git a/crates/tantivy/src/schema/field_type.rs b/crates/tantivy/src/schema/field_type.rs
index e496b982..39eeae85 100644
--- a/crates/tantivy/src/schema/field_type.rs
+++ b/crates/tantivy/src/schema/field_type.rs
@@ -246,6 +246,21 @@ impl FieldType {
}
}
+ /// returns true if the field is row ordered,
+ pub fn is_row_order(&self) -> bool {
+ match *self {
+ FieldType::Bytes(_)
+ | FieldType::Str(_)
+ | FieldType::Date(_)
+ | FieldType::IpAddr(_)
+ | FieldType::JsonObject(_) => false,
+ FieldType::U64(ref int_options)
+ | FieldType::I64(ref int_options)
+ | FieldType::F64(ref int_options)
+ | FieldType::Bool(ref int_options) => int_options.is_row_order(),
+ }
+ }
+
/// returns true if the field is normed (see [fieldnorms](crate::fieldnorm)).
pub fn has_fieldnorms(&self) -> bool {
match *self {
diff --git a/crates/tantivy/src/schema/flags.rs b/crates/tantivy/src/schema/flags.rs
index 92ab5cb8..29dcc914 100644
--- a/crates/tantivy/src/schema/flags.rs
+++ b/crates/tantivy/src/schema/flags.rs
@@ -55,6 +55,16 @@ pub const COLUMN: SchemaFlagList<ColumnarFlag, ()> = SchemaFlagList {
tail: (),
};
+#[derive(Clone)]
+pub struct RowOrderFlag;
+/// Flag to mark the field as a row ordered field.
+///
+/// Row ordered fields are designed for fast random access of all the values of a single document.
+pub const ROW_ORDER: SchemaFlagList<RowOrderFlag, ()> = SchemaFlagList {
+ head: RowOrderFlag,
+ tail: (),
+};
+
impl<Head, OldHead, OldTail> BitOr<SchemaFlagList<Head, ()>> for SchemaFlagList<OldHead, OldTail>
where
Head: Clone,
diff --git a/crates/tantivy/src/schema/mod.rs b/crates/tantivy/src/schema/mod.rs
index 41ce8e1e..887cf23f 100644
--- a/crates/tantivy/src/schema/mod.rs
+++ b/crates/tantivy/src/schema/mod.rs
@@ -132,7 +132,7 @@ pub use self::document::{DocParsingError, Document, OwnedValue, TantivyDocument,
pub use self::field::Field;
pub use self::field_entry::FieldEntry;
pub use self::field_type::{FieldType, Type};
-pub use self::flags::{COERCE, COLUMN, INDEXED, STORED};
+pub use self::flags::{COERCE, COLUMN, INDEXED, ROW_ORDER, STORED};
pub use self::index_record_option::IndexRecordOption;
pub use self::ip_options::{IntoIpv6Addr, IpAddrOptions};
pub use self::json_object_options::JsonObjectOptions;
diff --git a/crates/tantivy/src/schema/numeric_options.rs b/crates/tantivy/src/schema/numeric_options.rs
index d825c4c7..c3822a72 100644
--- a/crates/tantivy/src/schema/numeric_options.rs
+++ b/crates/tantivy/src/schema/numeric_options.rs
@@ -2,7 +2,7 @@ use std::ops::BitOr;
use serde::{Deserialize, Serialize};
-use super::flags::CoerceFlag;
+use super::flags::{CoerceFlag, RowOrderFlag};
use crate::schema::flags::{ColumnarFlag, IndexedFlag, SchemaFlagList, StoredFlag};
/// Define how an `u64`, `i64`, or `f64` field should be handled by tantivy.
@@ -13,6 +13,7 @@ pub struct NumericOptions {
// This boolean has no effect if the field is not marked as indexed too.
fieldnorms: bool, // This attribute only has an effect if indexed is true.
columnar: bool,
+ row_order: bool,
stored: bool,
#[serde(skip_serializing_if = "is_false")]
coerce: bool,
@@ -34,6 +35,8 @@ struct NumericOptionsDeser {
fieldnorms: Option<bool>, // This attribute only has an effect if indexed is true.
#[serde(default)]
columnar: bool,
+ #[serde(default)]
+ row_order: bool,
stored: bool,
#[serde(default)]
coerce: bool,
@@ -45,6 +48,7 @@ impl From<NumericOptionsDeser> for NumericOptions {
indexed: deser.indexed,
fieldnorms: deser.fieldnorms.unwrap_or(deser.indexed),
columnar: deser.columnar,
+ row_order: deser.row_order,
stored: deser.stored,
coerce: deser.coerce,
}
@@ -76,6 +80,12 @@ impl NumericOptions {
self.columnar
}
+ /// Returns true iff the value is a row-ordered field.
+ #[inline]
+ pub fn is_row_order(&self) -> bool {
+ self.row_order
+ }
+
/// Returns true if values should be coerced to numbers.
#[inline]
pub fn should_coerce(&self) -> bool {
@@ -129,6 +139,15 @@ impl NumericOptions {
self.columnar = true;
self
}
+
+ /// Set the field as a row-ordered field.
+ ///
+ /// Row-ordered fields are designed for random access of multiple column values for a single document.
+ #[must_use]
+ pub fn set_row_order(mut self) -> NumericOptions {
+ self.row_order = true;
+ self
+ }
}
impl From<()> for NumericOptions {
@@ -144,6 +163,7 @@ impl From<CoerceFlag> for NumericOptions {
fieldnorms: false,
stored: false,
columnar: false,
+ row_order: false,
coerce: true,
}
}
@@ -156,6 +176,20 @@ impl From<ColumnarFlag> for NumericOptions {
fieldnorms: false,
stored: false,
columnar: true,
+ row_order: false,
+ coerce: false,
+ }
+ }
+}
+
+impl From<RowOrderFlag> for NumericOptions {
+ fn from(_: RowOrderFlag) -> Self {
+ NumericOptions {
+ indexed: false,
+ fieldnorms: false,
+ stored: false,
+ columnar: false,
+ row_order: true,
coerce: false,
}
}
@@ -168,6 +202,7 @@ impl From<StoredFlag> for NumericOptions {
fieldnorms: false,
stored: true,
columnar: false,
+ row_order: false,
coerce: false,
}
}
@@ -180,6 +215,7 @@ impl From<IndexedFlag> for NumericOptions {
fieldnorms: true,
stored: false,
columnar: false,
+ row_order: false,
coerce: false,
}
}
@@ -195,6 +231,7 @@ impl<T: Into<NumericOptions>> BitOr<T> for NumericOptions {
fieldnorms: self.fieldnorms | other.fieldnorms,
stored: self.stored | other.stored,
columnar: self.columnar | other.columnar,
+ row_order: self.row_order | other.row_order,
coerce: self.coerce | other.coerce,
}
}
@@ -228,6 +265,7 @@ mod tests {
indexed: true,
fieldnorms: true,
columnar: false,
+ row_order: false,
stored: false,
coerce: false,
}
@@ -247,6 +285,7 @@ mod tests {
indexed: false,
fieldnorms: false,
columnar: false,
+ row_order: false,
stored: false,
coerce: false,
}
@@ -267,6 +306,7 @@ mod tests {
indexed: true,
fieldnorms: false,
columnar: false,
+ row_order: false,
stored: false,
coerce: false,
}
@@ -288,6 +328,7 @@ mod tests {
indexed: false,
fieldnorms: true,
columnar: false,
+ row_order: false,
stored: false,
coerce: false,
}
@@ -310,6 +351,7 @@ mod tests {
indexed: false,
fieldnorms: true,
columnar: false,
+ row_order: false,
stored: false,
coerce: true,
}
diff --git a/crates/tantivy/src/schema/schema.rs b/crates/tantivy/src/schema/schema.rs
index 035841c6..6f485c50 100644
--- a/crates/tantivy/src/schema/schema.rs
+++ b/crates/tantivy/src/schema/schema.rs
@@ -494,6 +494,7 @@ mod tests {
"indexed": false,
"fieldnorms": false,
"columnar": true,
+ "row_order": false,
"stored": true
}
},
@@ -504,6 +505,7 @@ mod tests {
"indexed": false,
"fieldnorms": false,
"columnar": true,
+ "row_order": false,
"stored": true
}
},
@@ -514,6 +516,7 @@ mod tests {
"indexed": true,
"fieldnorms": true,
"columnar": true,
+ "row_order": false,
"stored": false
}
},
@@ -524,6 +527,7 @@ mod tests {
"indexed": false,
"fieldnorms": false,
"columnar": true,
+ "row_order": false,
"stored": true
}
}
@@ -851,6 +855,7 @@ mod tests {
"indexed": false,
"fieldnorms": false,
"columnar": true,
+ "row_order": false,
"stored": true
}
}
@@ -908,6 +913,7 @@ mod tests {
"indexed": false,
"fieldnorms": false,
"columnar": true,
+ "row_order": false,
"stored": true
}
}
diff --git a/crates/tantivy/src/space_usage/mod.rs b/crates/tantivy/src/space_usage/mod.rs
index 17df8381..af966418 100644
--- a/crates/tantivy/src/space_usage/mod.rs
+++ b/crates/tantivy/src/space_usage/mod.rs
@@ -68,6 +68,7 @@ pub struct SegmentSpaceUsage {
postings: PerFieldSpaceUsage,
positions: PerFieldSpaceUsage,
column_fields: PerFieldSpaceUsage,
+ row_fields: PerFieldSpaceUsage,
fieldnorms: PerFieldSpaceUsage,
store: StoreSpaceUsage,
@@ -83,6 +84,7 @@ impl SegmentSpaceUsage {
postings: PerFieldSpaceUsage,
positions: PerFieldSpaceUsage,
column_fields: PerFieldSpaceUsage,
+ row_fields: PerFieldSpaceUsage,
fieldnorms: PerFieldSpaceUsage,
store: StoreSpaceUsage,
) -> SegmentSpaceUsage {
@@ -90,6 +92,7 @@ impl SegmentSpaceUsage {
+ postings.total()
+ positions.total()
+ column_fields.total()
+ + row_fields.total()
+ fieldnorms.total()
+ store.total();
SegmentSpaceUsage {
@@ -98,6 +101,7 @@ impl SegmentSpaceUsage {
postings,
positions,
column_fields,
+ row_fields,
fieldnorms,
store,
total,
@@ -115,6 +119,7 @@ impl SegmentSpaceUsage {
Postings => PerField(self.postings().clone()),
Positions => PerField(self.positions().clone()),
ColumnFields => PerField(self.column_fields().clone()),
+ RowFields => PerField(self.row_fields().clone()),
FieldNorms => PerField(self.fieldnorms().clone()),
Terms => PerField(self.termdict().clone()),
SegmentComponent::Store => ComponentSpaceUsage::Store(self.store().clone()),
@@ -147,6 +152,11 @@ impl SegmentSpaceUsage {
&self.column_fields
}
+ /// Space usage for row fields
+ pub fn row_fields(&self) -> &PerFieldSpaceUsage {
+ &self.row_fields
+ }
+
/// Space usage for field norms
pub fn fieldnorms(&self) -> &PerFieldSpaceUsage {
&self.fieldnorms