add mut methods

columnar/src/column_index/merge/mod.rs

@@ -168,8 +168,9 @@ mod tests {
  )
  .into();
  let merged_column_index = merge_column_index(&column_indexes[..], &merge_row_order);
- let SerializableColumnIndex::Multivalued(start_index_iterable) = merged_column_index
- else { panic!("Excpected a multivalued index") };
+ let SerializableColumnIndex::Multivalued(start_index_iterable) = merged_column_index else {
+ panic!("Excpected a multivalued index")
+ };
  let start_indexes: Vec<RowId> = start_index_iterable.boxed_iter().collect();
  assert_eq!(&start_indexes, &[0, 3, 5]);
  }
@@ -200,8 +201,9 @@ mod tests {
  )
  .into();
  let merged_column_index = merge_column_index(&column_indexes[..], &merge_row_order);
- let SerializableColumnIndex::Multivalued(start_index_iterable) = merged_column_index
- else { panic!("Excpected a multivalued index") };
+ let SerializableColumnIndex::Multivalued(start_index_iterable) = merged_column_index else {
+ panic!("Excpected a multivalued index")
+ };
  let start_indexes: Vec<RowId> = start_index_iterable.boxed_iter().collect();
  assert_eq!(&start_indexes, &[0, 3, 5, 6]);
  }

columnar/src/column_index/merge/shuffled.rs

@@ -157,7 +157,13 @@ mod tests {
  Cardinality::Optional,
  &shuffle_merge_order,
  );
- let SerializableColumnIndex::Optional { non_null_row_ids, num_rows } = serializable_index else { panic!() };
+ let SerializableColumnIndex::Optional {
+ non_null_row_ids,
+ num_rows,
+ } = serializable_index
+ else {
+ panic!()
+ };
  assert_eq!(num_rows, 2);
  let non_null_rows: Vec<RowId> = non_null_row_ids.boxed_iter().collect();
  assert_eq!(&non_null_rows, &[1]);

columnar/src/column_values/u64_based/bitpacked.rs

@@ -83,7 +83,8 @@ impl ColumnValues for BitpackedReader {
  doc_id_range: Range<u32>,
  positions: &mut Vec<u32>,
  ) {
- let Some(transformed_range) = transform_range_before_linear_transformation(&self.stats, range)
+ let Some(transformed_range) =
+ transform_range_before_linear_transformation(&self.stats, range)
  else {
  positions.clear();
  return;

columnar/src/columnar/merge/tests.rs

@@ -244,7 +244,9 @@ fn test_merge_columnar_numbers() {
  assert_eq!(columnar_reader.num_columns(), 1);
  let cols = columnar_reader.read_columns("numbers").unwrap();
  let dynamic_column = cols[0].open().unwrap();
- let DynamicColumn::F64(vals) = dynamic_column else { panic!() };
+ let DynamicColumn::F64(vals) = dynamic_column else {
+ panic!()
+ };
  assert_eq!(vals.get_cardinality(), Cardinality::Optional);
  assert_eq!(vals.first(0u32), Some(-1f64));
  assert_eq!(vals.first(1u32), None);
@@ -270,7 +272,9 @@ fn test_merge_columnar_texts() {
  assert_eq!(columnar_reader.num_columns(), 1);
  let cols = columnar_reader.read_columns("texts").unwrap();
  let dynamic_column = cols[0].open().unwrap();
- let DynamicColumn::Str(vals) = dynamic_column else { panic!() };
+ let DynamicColumn::Str(vals) = dynamic_column else {
+ panic!()
+ };
  assert_eq!(vals.ords().get_cardinality(), Cardinality::Optional);
 
  let get_str_for_ord = |ord| {
@@ -317,7 +321,9 @@ fn test_merge_columnar_byte() {
  assert_eq!(columnar_reader.num_columns(), 1);
  let cols = columnar_reader.read_columns("bytes").unwrap();
  let dynamic_column = cols[0].open().unwrap();
- let DynamicColumn::Bytes(vals) = dynamic_column else { panic!() };
+ let DynamicColumn::Bytes(vals) = dynamic_column else {
+ panic!()
+ };
  let get_bytes_for_ord = |ord| {
  let mut out = Vec::new();
  vals.ord_to_bytes(ord, &mut out).unwrap();
@@ -371,7 +377,9 @@ fn test_merge_columnar_byte_with_missing() {
  assert_eq!(columnar_reader.num_columns(), 2);
  let cols = columnar_reader.read_columns("col").unwrap();
  let dynamic_column = cols[0].open().unwrap();
- let DynamicColumn::Bytes(vals) = dynamic_column else { panic!() };
+ let DynamicColumn::Bytes(vals) = dynamic_column else {
+ panic!()
+ };
  let get_bytes_for_ord = |ord| {
  let mut out = Vec::new();
  vals.ord_to_bytes(ord, &mut out).unwrap();
@@ -423,7 +431,9 @@ fn test_merge_columnar_different_types() {
 
  // numeric column
  let dynamic_column = cols[0].open().unwrap();
- let DynamicColumn::I64(vals) = dynamic_column else { panic!() };
+ let DynamicColumn::I64(vals) = dynamic_column else {
+ panic!()
+ };
  assert_eq!(vals.get_cardinality(), Cardinality::Optional);
  assert_eq!(vals.values_for_doc(0).collect_vec(), vec![]);
  assert_eq!(vals.values_for_doc(1).collect_vec(), vec![]);
@@ -433,7 +443,9 @@ fn test_merge_columnar_different_types() {
 
  // text column
  let dynamic_column = cols[1].open().unwrap();
- let DynamicColumn::Str(vals) = dynamic_column else { panic!() };
+ let DynamicColumn::Str(vals) = dynamic_column else {
+ panic!()
+ };
  assert_eq!(vals.ords().get_cardinality(), Cardinality::Optional);
  let get_str_for_ord = |ord| {
  let mut out = String::new();

columnar/src/columnar/writer/mod.rs

@@ -98,9 +98,11 @@ impl ColumnarWriter {
  ///
  /// The sort applied is stable.
  pub fn sort_order(&self, sort_field: &str, num_docs: RowId, reversed: bool) -> Vec<u32> {
- let Some(numerical_col_writer) =
- self.numerical_field_hash_map.get::<NumericalColumnWriter>(sort_field.as_bytes()) else {
- return Vec::new();
+ let Some(numerical_col_writer) = self
+ .numerical_field_hash_map
+ .get::<NumericalColumnWriter>(sort_field.as_bytes())
+ else {
+ return Vec::new();
  };
  let mut symbols_buffer = Vec::new();
  let mut values = Vec::new();

columnar/src/tests.rs

@@ -57,7 +57,9 @@ fn test_dataframe_writer_bool() {
  assert_eq!(cols[0].num_bytes(), 22);
  assert_eq!(cols[0].column_type(), ColumnType::Bool);
  let dyn_bool_col = cols[0].open().unwrap();
- let DynamicColumn::Bool(bool_col) = dyn_bool_col else { panic!(); };
+ let DynamicColumn::Bool(bool_col) = dyn_bool_col else {
+ panic!();
+ };
  let vals: Vec<Option<bool>> = (0..5).map(|row_id| bool_col.first(row_id)).collect();
  assert_eq!(&vals, &[None, Some(false), None, Some(true), None,]);
 }
@@ -79,7 +81,9 @@ fn test_dataframe_writer_u64_multivalued() {
  assert_eq!(cols.len(), 1);
  assert_eq!(cols[0].num_bytes(), 29);
  let dyn_i64_col = cols[0].open().unwrap();
- let DynamicColumn::I64(divisor_col) = dyn_i64_col else { panic!(); };
+ let DynamicColumn::I64(divisor_col) = dyn_i64_col else {
+ panic!();
+ };
  assert_eq!(
  divisor_col.get_cardinality(),
  crate::Cardinality::Multivalued
@@ -101,7 +105,9 @@ fn test_dataframe_writer_ip_addr() {
  assert_eq!(cols[0].num_bytes(), 42);
  assert_eq!(cols[0].column_type(), ColumnType::IpAddr);
  let dyn_bool_col = cols[0].open().unwrap();
- let DynamicColumn::IpAddr(ip_col) = dyn_bool_col else { panic!(); };
+ let DynamicColumn::IpAddr(ip_col) = dyn_bool_col else {
+ panic!();
+ };
  let vals: Vec<Option<Ipv6Addr>> = (0..5).map(|row_id| ip_col.first(row_id)).collect();
  assert_eq!(
  &vals,
@@ -134,7 +140,9 @@ fn test_dataframe_writer_numerical() {
  // - null footer 6 bytes
  assert_eq!(cols[0].num_bytes(), 33);
  let column = cols[0].open().unwrap();
- let DynamicColumn::I64(column_i64) = column else { panic!(); };
+ let DynamicColumn::I64(column_i64) = column else {
+ panic!();
+ };
  assert_eq!(column_i64.index.get_cardinality(), Cardinality::Optional);
  assert_eq!(column_i64.first(0), None);
  assert_eq!(column_i64.first(1), Some(12i64));
@@ -198,7 +206,9 @@ fn test_dictionary_encoded_str() {
  assert_eq!(columnar_reader.num_columns(), 2);
  let col_handles = columnar_reader.read_columns("my.column").unwrap();
  assert_eq!(col_handles.len(), 1);
- let DynamicColumn::Str(str_col) = col_handles[0].open().unwrap() else { panic!(); };
+ let DynamicColumn::Str(str_col) = col_handles[0].open().unwrap() else {
+ panic!();
+ };
  let index: Vec<Option<u64>> = (0..5).map(|row_id| str_col.ords().first(row_id)).collect();
  assert_eq!(index, &[None, Some(0), None, Some(2), Some(1)]);
  assert_eq!(str_col.num_rows(), 5);
@@ -230,7 +240,9 @@ fn test_dictionary_encoded_bytes() {
  assert_eq!(columnar_reader.num_columns(), 2);
  let col_handles = columnar_reader.read_columns("my.column").unwrap();
  assert_eq!(col_handles.len(), 1);
- let DynamicColumn::Bytes(bytes_col) = col_handles[0].open().unwrap() else { panic!(); };
+ let DynamicColumn::Bytes(bytes_col) = col_handles[0].open().unwrap() else {
+ panic!();
+ };
  let index: Vec<Option<u64>> = (0..5)
  .map(|row_id| bytes_col.ords().first(row_id))
  .collect();
@@ -533,28 +545,36 @@ trait AssertEqualToColumnValue {
 
 impl AssertEqualToColumnValue for bool {
  fn assert_equal_to_column_value(&self, column_value: &ColumnValue) {
- let ColumnValue::Bool(val) = column_value else { panic!() };
+ let ColumnValue::Bool(val) = column_value else {
+ panic!()
+ };
  assert_eq!(self, val);
  }
 }
 
 impl AssertEqualToColumnValue for Ipv6Addr {
  fn assert_equal_to_column_value(&self, column_value: &ColumnValue) {
- let ColumnValue::IpAddr(val) = column_value else { panic!() };
+ let ColumnValue::IpAddr(val) = column_value else {
+ panic!()
+ };
  assert_eq!(self, val);
  }
 }
 
 impl<T: Coerce + PartialEq + Debug + Into<NumericalValue>> AssertEqualToColumnValue for T {
  fn assert_equal_to_column_value(&self, column_value: &ColumnValue) {
- let ColumnValue::Numerical(num) = column_value else { panic!() };
+ let ColumnValue::Numerical(num) = column_value else {
+ panic!()
+ };
  assert_eq!(self, &T::coerce(*num));
  }
 }
 
 impl AssertEqualToColumnValue for DateTime {
  fn assert_equal_to_column_value(&self, column_value: &ColumnValue) {
- let ColumnValue::DateTime(dt) = column_value else { panic!() };
+ let ColumnValue::DateTime(dt) = column_value else {
+ panic!()
+ };
  assert_eq!(self, dt);
  }
 }

src/fastfield/readers.rs

@@ -88,7 +88,7 @@ impl FastFieldReaders {
  let Some((field, path)): Option<(Field, &str)> = self
  .schema
  .find_field_with_default(field_name, default_field_opt)
- else{
+ else {
  return Ok(None);
  };
  let field_entry: &FieldEntry = self.schema.get_field_entry(field);
@@ -120,7 +120,8 @@ impl FastFieldReaders {
  T: HasAssociatedColumnType,
  DynamicColumn: Into<Option<Column<T>>>,
  {
- let Some(dynamic_column_handle) = self.dynamic_column_handle(field_name, T::column_type())?
+ let Some(dynamic_column_handle) =
+ self.dynamic_column_handle(field_name, T::column_type())?
  else {
  return Ok(None);
  };
@@ -196,7 +197,8 @@ impl FastFieldReaders {
 
  /// Returns a `str` column.
  pub fn str(&self, field_name: &str) -> crate::Result<Option<StrColumn>> {
- let Some(dynamic_column_handle) = self.dynamic_column_handle(field_name, ColumnType::Str)?
+ let Some(dynamic_column_handle) =
+ self.dynamic_column_handle(field_name, ColumnType::Str)?
  else {
  return Ok(None);
  };
@@ -206,7 +208,8 @@ impl FastFieldReaders {
 
  /// Returns a `bytes` column.
  pub fn bytes(&self, field_name: &str) -> crate::Result<Option<BytesColumn>> {
- let Some(dynamic_column_handle) = self.dynamic_column_handle(field_name, ColumnType::Bytes)?
+ let Some(dynamic_column_handle) =
+ self.dynamic_column_handle(field_name, ColumnType::Bytes)?
  else {
  return Ok(None);
  };

src/query/range_query/range_query_ip_fastfield.rs

@@ -31,9 +31,10 @@ impl IPFastFieldRangeWeight {
 
 impl Weight for IPFastFieldRangeWeight {
  fn scorer(&self, reader: &SegmentReader, boost: Score) -> crate::Result<Box<dyn Scorer>> {
- let Some(ip_addr_column): Option<Column<Ipv6Addr>> = reader.fast_fields()
- .column_opt(&self.field)? else {
- return Ok(Box::new(EmptyScorer))
+ let Some(ip_addr_column): Option<Column<Ipv6Addr>> =
+ reader.fast_fields().column_opt(&self.field)?
+ else {
+ return Ok(Box::new(EmptyScorer));
  };
  let value_range = bound_to_value_range(
  &self.lower_bound,

src/query/range_query/range_query_u64_fastfield.rs

@@ -71,7 +71,9 @@ impl Weight for FastFieldRangeWeight {
  let column_type_opt_ref: Option<&[ColumnType]> = column_type_opt
  .as_ref()
  .map(|column_types| column_types.as_slice());
- let Some((column, _)) = fast_field_reader.u64_lenient_for_type(column_type_opt_ref, &self.field)? else {
+ let Some((column, _)) =
+ fast_field_reader.u64_lenient_for_type(column_type_opt_ref, &self.field)?
+ else {
  return Ok(Box::new(EmptyScorer));
  };
  let value_range = bound_to_value_range(

src/schema/document.rs

@@ -193,11 +193,24 @@ impl Document {
  .map(FieldValue::value)
  }
 
+ /// Returns all of the `FieldValue`s associated the given field
+ pub fn get_all_mut(&mut self, field: Field) -> impl Iterator<Item = &mut Value> {
+ self.field_values
+ .iter_mut()
+ .filter(move |field_value| field_value.field() == field)
+ .map(FieldValue::value_mut)
+ }
+
  /// Returns the first `FieldValue` associated the given field
  pub fn get_first(&self, field: Field) -> Option<&Value> {
  self.get_all(field).next()
  }
 
+ /// Returns the first `FieldValue` associated the given field
+ pub fn get_first_mut(&mut self, field: Field) -> Option<&mut Value> {
+ self.get_all_mut(field).next()
+ }
+
  /// Serializes stored field values.
  pub fn serialize_stored<W: Write>(&self, schema: &Schema, writer: &mut W) -> io::Result<()> {
  let stored_field_values = || {

src/schema/field_value.rs

@@ -27,6 +27,11 @@ impl FieldValue {
  pub fn value(&self) -> &Value {
  &self.value
  }
+
+ /// Value accessor
+ pub fn value_mut(&mut self) -> &mut Value {
+ &mut self.value
+ }
 }
 
 impl From<FieldValue> for Value {