web search done right
random access row ordered fields for ints, floats and bools.
Mikkel Denkerffb2a2a0a071
diff --git a/Cargo.lock b/Cargo.lockindex 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.tomlindex 86e823ab..27d47866 100644--- a/crates/tantivy/Cargo.toml+++ b/crates/tantivy/Cargo.toml@@ -49,6 +49,7 @@ rustc-hash.workspace = trueserde.workspace = trueserde_json.workspace = truesmallvec.workspace = true+strum.workspace = truetempfile = {workspace = true, optional = true}thiserror.workspace = truetime.workspace = truediff --git a/crates/tantivy/src/index/index_meta.rs b/crates/tantivy/src/index/index_meta.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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-20index_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-1000let 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.rsindex 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.rsindex 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_mapif 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.rsindex 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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>whereHead: Clone,diff --git a/crates/tantivy/src/schema/mod.rs b/crates/tantivy/src/schema/mod.rsindex 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.rsindex 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.rsindex 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.rsindex 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 normspub fn fieldnorms(&self) -> &PerFieldSpaceUsage {&self.fieldnorms