Merge pull request quickwit-oss#1334 from PSeitz/minor_fixes

fix DateTime naming, fix docs, cleanup

src/collector/histogram_collector.rs

@@ -273,18 +273,18 @@ mod tests {
         let schema = schema_builder.build();
         let index = Index::create_in_ram(schema);
         let mut writer = index.writer_with_num_threads(1, 4_000_000)?;
-        writer.add_document(doc!(date_field=>DateTime::new_primitive(Date::from_calendar_date(1982, Month::September, 17)?.with_hms(0, 0, 0)?)))?;
+        writer.add_document(doc!(date_field=>DateTime::from_primitive(Date::from_calendar_date(1982, Month::September, 17)?.with_hms(0, 0, 0)?)))?;
         writer.add_document(
-            doc!(date_field=>DateTime::new_primitive(Date::from_calendar_date(1986, Month::March, 9)?.with_hms(0, 0, 0)?)),
+            doc!(date_field=>DateTime::from_primitive(Date::from_calendar_date(1986, Month::March, 9)?.with_hms(0, 0, 0)?)),
         )?;
-        writer.add_document(doc!(date_field=>DateTime::new_primitive(Date::from_calendar_date(1983, Month::September, 27)?.with_hms(0, 0, 0)?)))?;
+        writer.add_document(doc!(date_field=>DateTime::from_primitive(Date::from_calendar_date(1983, Month::September, 27)?.with_hms(0, 0, 0)?)))?;
         writer.commit()?;
         let reader = index.reader()?;
         let searcher = reader.searcher();
         let all_query = AllQuery;
         let week_histogram_collector = HistogramCollector::new(
             date_field,
-            DateTime::new_primitive(
+            DateTime::from_primitive(
                 Date::from_calendar_date(1980, Month::January, 1)?.with_hms(0, 0, 0)?,
             ),
             3600 * 24 * 365, // it is just for a unit test... sorry leap years.

src/collector/tests.rs

@@ -26,11 +26,11 @@ pub fn test_filter_collector() -> crate::Result<()> {
     let index = Index::create_in_ram(schema);
 
     let mut index_writer = index.writer_with_num_threads(1, 10_000_000)?;
-    index_writer.add_document(doc!(title => "The Name of the Wind", price => 30_200u64, date => DateTime::new_utc(OffsetDateTime::parse("1898-04-09T00:00:00+00:00", &Rfc3339).unwrap())))?;
-    index_writer.add_document(doc!(title => "The Diary of Muadib", price => 29_240u64, date => DateTime::new_utc(OffsetDateTime::parse("2020-04-09T00:00:00+00:00", &Rfc3339).unwrap())))?;
-    index_writer.add_document(doc!(title => "The Diary of Anne Frank", price => 18_240u64, date => DateTime::new_utc(OffsetDateTime::parse("2019-04-20T00:00:00+00:00", &Rfc3339).unwrap())))?;
-    index_writer.add_document(doc!(title => "A Dairy Cow", price => 21_240u64, date => DateTime::new_utc(OffsetDateTime::parse("2019-04-09T00:00:00+00:00", &Rfc3339).unwrap())))?;
-    index_writer.add_document(doc!(title => "The Diary of a Young Girl", price => 20_120u64, date => DateTime::new_utc(OffsetDateTime::parse("2018-04-09T00:00:00+00:00", &Rfc3339).unwrap())))?;
+    index_writer.add_document(doc!(title => "The Name of the Wind", price => 30_200u64, date => DateTime::from_utc(OffsetDateTime::parse("1898-04-09T00:00:00+00:00", &Rfc3339).unwrap())))?;
+    index_writer.add_document(doc!(title => "The Diary of Muadib", price => 29_240u64, date => DateTime::from_utc(OffsetDateTime::parse("2020-04-09T00:00:00+00:00", &Rfc3339).unwrap())))?;
+    index_writer.add_document(doc!(title => "The Diary of Anne Frank", price => 18_240u64, date => DateTime::from_utc(OffsetDateTime::parse("2019-04-20T00:00:00+00:00", &Rfc3339).unwrap())))?;
+    index_writer.add_document(doc!(title => "A Dairy Cow", price => 21_240u64, date => DateTime::from_utc(OffsetDateTime::parse("2019-04-09T00:00:00+00:00", &Rfc3339).unwrap())))?;
+    index_writer.add_document(doc!(title => "The Diary of a Young Girl", price => 20_120u64, date => DateTime::from_utc(OffsetDateTime::parse("2018-04-09T00:00:00+00:00", &Rfc3339).unwrap())))?;
     index_writer.commit()?;
 
     let reader = index.reader()?;
@@ -55,7 +55,7 @@ pub fn test_filter_collector() -> crate::Result<()> {
     assert_eq!(filtered_top_docs.len(), 0);
 
     fn date_filter(value: DateTime) -> bool {
-        (value.to_utc() - OffsetDateTime::parse("2019-04-09T00:00:00+00:00", &Rfc3339).unwrap())
+        (value.into_utc() - OffsetDateTime::parse("2019-04-09T00:00:00+00:00", &Rfc3339).unwrap())
             .whole_weeks()
             > 0
     }

src/collector/top_score_collector.rs

@@ -898,15 +898,15 @@ mod tests {
         let schema = schema_builder.build();
         let index = Index::create_in_ram(schema);
         let mut index_writer = index.writer_for_tests()?;
-        let pr_birthday = DateTime::new_utc(OffsetDateTime::parse(
+        let pr_birthday = DateTime::from_utc(OffsetDateTime::parse(
             "1898-04-09T00:00:00+00:00",
             &Rfc3339,
         )?);
         index_writer.add_document(doc!(
             name => "Paul Robeson",
             birthday => pr_birthday,
         ))?;
-        let mr_birthday = DateTime::new_utc(OffsetDateTime::parse(
+        let mr_birthday = DateTime::from_utc(OffsetDateTime::parse(
             "1947-11-08T00:00:00+00:00",
             &Rfc3339,
         )?);

src/fastfield/alive_bitset.rs

@@ -188,14 +188,14 @@ mod bench {
     }
 
     #[bench]
-    fn bench_deletebitset_iter_deser_on_fly(bench: &mut Bencher) {
+    fn bench_alive_bitset_iter_deser_on_fly(bench: &mut Bencher) {
         let alive_bitset = AliveBitSet::for_test_from_deleted_docs(&[0, 1, 1000, 10000], 1_000_000);
 
         bench.iter(|| alive_bitset.iter_alive().collect::<Vec<_>>());
     }
 
     #[bench]
-    fn bench_deletebitset_access(bench: &mut Bencher) {
+    fn bench_alive_bitset_access(bench: &mut Bencher) {
         let alive_bitset = AliveBitSet::for_test_from_deleted_docs(&[0, 1, 1000, 10000], 1_000_000);
 
         bench.iter(|| {
@@ -206,14 +206,14 @@ mod bench {
     }
 
     #[bench]
-    fn bench_deletebitset_iter_deser_on_fly_1_8_alive(bench: &mut Bencher) {
+    fn bench_alive_bitset_iter_deser_on_fly_1_8_alive(bench: &mut Bencher) {
         let alive_bitset = AliveBitSet::for_test_from_deleted_docs(&get_alive(), 1_000_000);
 
         bench.iter(|| alive_bitset.iter_alive().collect::<Vec<_>>());
     }
 
     #[bench]
-    fn bench_deletebitset_access_1_8_alive(bench: &mut Bencher) {
+    fn bench_alive_bitset_access_1_8_alive(bench: &mut Bencher) {
         let alive_bitset = AliveBitSet::for_test_from_deleted_docs(&get_alive(), 1_000_000);
 
         bench.iter(|| {

src/fastfield/mod.rs

@@ -167,7 +167,7 @@ impl FastValue for DateTime {
     }
 
     fn to_u64(&self) -> u64 {
-        self.to_unix_timestamp().to_u64()
+        self.into_unix_timestamp().to_u64()
     }
 
     fn fast_field_cardinality(field_type: &FieldType) -> Option<Cardinality> {
@@ -178,7 +178,7 @@ impl FastValue for DateTime {
     }
 
     fn as_u64(&self) -> u64 {
-        self.to_unix_timestamp().as_u64()
+        self.into_unix_timestamp().as_u64()
     }
 
     fn to_type() -> Type {
@@ -254,7 +254,7 @@ mod tests {
 
     #[test]
     pub fn test_fastfield_i64_u64() {
-        let datetime = DateTime::new_utc(OffsetDateTime::UNIX_EPOCH);
+        let datetime = DateTime::from_utc(OffsetDateTime::UNIX_EPOCH);
         assert_eq!(i64::from_u64(datetime.to_u64()), 0i64);
     }
 
@@ -511,7 +511,7 @@ mod tests {
         let mut index_writer = index.writer_for_tests().unwrap();
         index_writer.set_merge_policy(Box::new(NoMergePolicy));
         index_writer
-            .add_document(doc!(date_field =>DateTime::new_utc(OffsetDateTime::now_utc())))?;
+            .add_document(doc!(date_field =>DateTime::from_utc(OffsetDateTime::now_utc())))?;
         index_writer.commit()?;
         index_writer.add_document(doc!())?;
         index_writer.commit()?;
@@ -531,7 +531,7 @@ mod tests {
 
     #[test]
     fn test_default_datetime() {
-        assert_eq!(0, DateTime::make_zero().to_unix_timestamp());
+        assert_eq!(0, DateTime::make_zero().into_unix_timestamp());
     }
 
     fn get_vals_for_docs(ff: &MultiValuedFastFieldReader<u64>, docs: Range<u32>) -> Vec<u64> {
@@ -768,23 +768,23 @@ mod tests {
         let dates_fast_field = fast_fields.dates(multi_date_field).unwrap();
         let mut dates = vec![];
         {
-            assert_eq!(date_fast_field.get(0u32).to_unix_timestamp(), 1i64);
+            assert_eq!(date_fast_field.get(0u32).into_unix_timestamp(), 1i64);
             dates_fast_field.get_vals(0u32, &mut dates);
             assert_eq!(dates.len(), 2);
-            assert_eq!(dates[0].to_unix_timestamp(), 2i64);
-            assert_eq!(dates[1].to_unix_timestamp(), 3i64);
+            assert_eq!(dates[0].into_unix_timestamp(), 2i64);
+            assert_eq!(dates[1].into_unix_timestamp(), 3i64);
         }
         {
-            assert_eq!(date_fast_field.get(1u32).to_unix_timestamp(), 4i64);
+            assert_eq!(date_fast_field.get(1u32).into_unix_timestamp(), 4i64);
             dates_fast_field.get_vals(1u32, &mut dates);
             assert!(dates.is_empty());
         }
         {
-            assert_eq!(date_fast_field.get(2u32).to_unix_timestamp(), 0i64);
+            assert_eq!(date_fast_field.get(2u32).into_unix_timestamp(), 0i64);
             dates_fast_field.get_vals(2u32, &mut dates);
             assert_eq!(dates.len(), 2);
-            assert_eq!(dates[0].to_unix_timestamp(), 5i64);
-            assert_eq!(dates[1].to_unix_timestamp(), 6i64);
+            assert_eq!(dates[0].into_unix_timestamp(), 5i64);
+            assert_eq!(dates[1].into_unix_timestamp(), 6i64);
         }
         Ok(())
     }

src/fastfield/multivalued/mod.rs

@@ -71,24 +71,24 @@ mod tests {
         let mut index_writer = index.writer_for_tests()?;
         let first_time_stamp = OffsetDateTime::now_utc();
         index_writer.add_document(doc!(
-                date_field => DateTime::new_utc(first_time_stamp),
-                date_field => DateTime::new_utc(first_time_stamp),
+                date_field => DateTime::from_utc(first_time_stamp),
+                date_field => DateTime::from_utc(first_time_stamp),
                 time_i=>1i64))?;
         index_writer.add_document(doc!(time_i => 0i64))?;
         // add one second
         index_writer.add_document(doc!(
-            date_field => DateTime::new_utc(first_time_stamp + Duration::seconds(1)),
+            date_field => DateTime::from_utc(first_time_stamp + Duration::seconds(1)),
             time_i => 2i64))?;
         // add another second
         let two_secs_ahead = first_time_stamp + Duration::seconds(2);
         index_writer.add_document(doc!(
-            date_field => DateTime::new_utc(two_secs_ahead),
-            date_field => DateTime::new_utc(two_secs_ahead),
-            date_field => DateTime::new_utc(two_secs_ahead),
+            date_field => DateTime::from_utc(two_secs_ahead),
+            date_field => DateTime::from_utc(two_secs_ahead),
+            date_field => DateTime::from_utc(two_secs_ahead),
             time_i => 3i64))?;
         // add three seconds
         index_writer.add_document(doc!(
-                date_field => DateTime::new_utc(first_time_stamp + Duration::seconds(3)),
+                date_field => DateTime::from_utc(first_time_stamp + Duration::seconds(3)),
                 time_i => 4i64))?;
         index_writer.commit()?;
 
@@ -113,7 +113,7 @@ mod tests {
                         .expect("cannot find value")
                         .as_date()
                         .unwrap(),
-                    DateTime::new_utc(first_time_stamp),
+                    DateTime::from_utc(first_time_stamp),
                 );
                 assert_eq!(
                     retrieved_doc
@@ -140,7 +140,7 @@ mod tests {
                         .expect("cannot find value")
                         .as_date()
                         .unwrap(),
-                    DateTime::new_utc(two_secs_ahead)
+                    DateTime::from_utc(two_secs_ahead)
                 );
                 assert_eq!(
                     retrieved_doc
@@ -181,7 +181,7 @@ mod tests {
                         .expect("cannot find value")
                         .as_date()
                         .expect("value not of Date type"),
-                    DateTime::new_utc(first_time_stamp + Duration::seconds(offset_sec)),
+                    DateTime::from_utc(first_time_stamp + Duration::seconds(offset_sec)),
                 );
                 assert_eq!(
                     retrieved_doc

src/indexer/demuxer.rs

@@ -116,14 +116,14 @@ pub fn demux(
 ) -> crate::Result<Vec<Index>> {
     let mut indices = vec![];
     for (target_segment_ord, output_directory) in output_directories.into_iter().enumerate() {
-        let delete_bitsets = get_alive_bitsets(demux_mapping, target_segment_ord as u32)
+        let alive_bitset = get_alive_bitsets(demux_mapping, target_segment_ord as u32)
             .into_iter()
             .map(Some)
             .collect_vec();
         let index = merge_filtered_segments(
             segments,
             target_settings.clone(),
-            delete_bitsets,
+            alive_bitset,
             output_directory,
         )?;
         indices.push(index);
@@ -141,7 +141,7 @@ mod tests {
     use crate::{DocAddress, Term};
 
     #[test]
-    fn test_demux_map_to_deletebitset() {
+    fn test_demux_map_to_alive_bitset() {
         let max_value = 2;
         let mut demux_mapping = DemuxMapping::default();
         // segment ordinal 0 mapping

src/indexer/json_term_writer.rs

@@ -153,7 +153,7 @@ fn index_json_value<'a>(
                 );
             }
             TextOrDateTime::DateTime(dt) => {
-                json_term_writer.set_fast_value(DateTime::new_utc(dt));
+                json_term_writer.set_fast_value(DateTime::from_utc(dt));
                 postings_writer.subscribe(doc, 0u32, json_term_writer.term(), ctx);
             }
         },

src/indexer/merger.rs

@@ -170,8 +170,8 @@ impl IndexMerger {
         index_settings: IndexSettings,
         segments: &[Segment],
     ) -> crate::Result<IndexMerger> {
-        let delete_bitsets = segments.iter().map(|_| None).collect_vec();
-        Self::open_with_custom_alive_set(schema, index_settings, segments, delete_bitsets)
+        let alive_bitset = segments.iter().map(|_| None).collect_vec();
+        Self::open_with_custom_alive_set(schema, index_settings, segments, alive_bitset)
     }
 
     // Create merge with a custom delete set.
@@ -180,7 +180,7 @@ impl IndexMerger {
     // corresponds to the segment index.
     //
     // If `None` is provided for custom alive set, the regular alive set will be used.
-    // If a delete_bitsets is provided, the union between the provided and regular
+    // If a alive_bitset is provided, the union between the provided and regular
     // alive set will be used.
     //
     // This can be used to merge but also apply an additional filter.
@@ -1177,7 +1177,7 @@ mod tests {
             index_writer.add_document(doc!(
                 text_field => "af b",
                 score_field => 3u64,
-                date_field => DateTime::new_utc(curr_time),
+                date_field => DateTime::from_utc(curr_time),
                 bytes_score_field => 3u32.to_be_bytes().as_ref()
             ))?;
             index_writer.add_document(doc!(
@@ -1194,7 +1194,7 @@ mod tests {
             // writing the segment
             index_writer.add_document(doc!(
                 text_field => "af b",
-                date_field => DateTime::new_utc(curr_time),
+                date_field => DateTime::from_utc(curr_time),
                 score_field => 11u64,
                 bytes_score_field => 11u32.to_be_bytes().as_ref()
             ))?;
@@ -1252,7 +1252,7 @@ mod tests {
                 assert_eq!(
                     get_doc_ids(vec![Term::from_field_date(
                         date_field,
-                        DateTime::new_utc(curr_time)
+                        DateTime::from_utc(curr_time)
                     )])?,
                     vec![DocAddress::new(0, 0), DocAddress::new(0, 3)]
                 );

src/indexer/segment_writer.rs

@@ -527,7 +527,7 @@ mod tests {
         json_term_writer.pop_path_segment();
         json_term_writer.pop_path_segment();
         json_term_writer.push_path_segment("date");
-        json_term_writer.set_fast_value(DateTime::new_utc(
+        json_term_writer.set_fast_value(DateTime::from_utc(
             OffsetDateTime::parse("1985-04-12T23:20:50.52Z", &Rfc3339).unwrap(),
         ));
         assert!(term_stream.advance());

src/lib.rs

@@ -158,27 +158,27 @@ impl DateTime {
     ///
     /// The given date/time is converted to UTC and the actual
     /// time zone is discarded.
-    pub const fn new_utc(dt: OffsetDateTime) -> Self {
+    pub const fn from_utc(dt: OffsetDateTime) -> Self {
         Self::from_unix_timestamp(dt.unix_timestamp())
     }
 
     /// Create new from `PrimitiveDateTime`
     ///
     /// Implicitly assumes that the given date/time is in UTC!
     /// Otherwise the original value must only be reobtained with
-    /// [`to_primitive()`].
-    pub const fn new_primitive(dt: PrimitiveDateTime) -> Self {
-        Self::new_utc(dt.assume_utc())
+    /// [`Self::into_primitive()`].
+    pub const fn from_primitive(dt: PrimitiveDateTime) -> Self {
+        Self::from_utc(dt.assume_utc())
     }
 
     /// Convert to UNIX timestamp
-    pub const fn to_unix_timestamp(self) -> i64 {
+    pub const fn into_unix_timestamp(self) -> i64 {
         let Self { unix_timestamp } = self;
         unix_timestamp
     }
 
     /// Convert to UTC `OffsetDateTime`
-    pub fn to_utc(self) -> OffsetDateTime {
+    pub fn into_utc(self) -> OffsetDateTime {
         let Self { unix_timestamp } = self;
         let utc_datetime =
             OffsetDateTime::from_unix_timestamp(unix_timestamp).expect("valid UNIX timestamp");
@@ -187,16 +187,16 @@ impl DateTime {
     }
 
     /// Convert to `OffsetDateTime` with the given time zone
-    pub fn to_offset(self, offset: UtcOffset) -> OffsetDateTime {
-        self.to_utc().to_offset(offset)
+    pub fn into_offset(self, offset: UtcOffset) -> OffsetDateTime {
+        self.into_utc().to_offset(offset)
     }
 
     /// Convert to `PrimitiveDateTime` without any time zone
     ///
-    /// The value should have been constructed with [`from_primitive()`].
+    /// The value should have been constructed with [`Self::from_primitive()`].
     /// Otherwise the time zone is implicitly assumed to be UTC.
-    pub fn to_primitive(self) -> PrimitiveDateTime {
-        let utc_datetime = self.to_utc();
+    pub fn into_primitive(self) -> PrimitiveDateTime {
+        let utc_datetime = self.into_utc();
         // Discard the UTC time zone offset
         debug_assert_eq!(UtcOffset::UTC, utc_datetime.offset());
         PrimitiveDateTime::new(utc_datetime.date(), utc_datetime.time())
@@ -205,7 +205,7 @@ impl DateTime {
 
 impl fmt::Debug for DateTime {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let utc_rfc3339 = self.to_utc().format(&Rfc3339).map_err(|_| fmt::Error)?;
+        let utc_rfc3339 = self.into_utc().format(&Rfc3339).map_err(|_| fmt::Error)?;
         f.write_str(&utc_rfc3339)
     }
 }