diff --git a/src/fastfield/mod.rs b/src/fastfield/mod.rs
index ece6c4634..d72f8cd51 100644
--- a/src/fastfield/mod.rs
+++ b/src/fastfield/mod.rs
@@ -823,30 +823,25 @@ mod tests {
     }
 
     #[test]
-    pub fn test_fastfield_bool_default_value() -> crate::Result<()> {
+    pub fn test_fastfield_bool_default_value() {
         let path = Path::new("test_bool");
         let directory: RamDirectory = RamDirectory::create();
-
         let mut schema_builder = Schema::builder();
         let field = schema_builder.add_bool_field("field_bool", FAST);
         let schema = schema_builder.build();
-
         {
             let mut write: WritePtr = directory.open_write(path).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
             let doc = Document::default();
             fast_field_writers.add_document(&doc).unwrap();
-            fast_field_writers.serialize(&mut write, None)?;
-            write.terminate()?;
+            fast_field_writers.serialize(&mut write, None).unwrap();
+            write.terminate().unwrap();
         }
         let file = directory.open_read(path).unwrap();
-        let composite_file = CompositeFile::open(&file)?;
-        assert_eq!(file.len(), 32);
-        let data = composite_file.open_read(field).unwrap().read_bytes()?;
-        let fast_field_reader = open::<bool>(data)?;
-        assert_eq!(fast_field_reader.get_val(0), false);
-
-        Ok(())
+        assert_eq!(file.len(), 45);
+        let fastfield_readers = FastFieldReaders::open(file).unwrap();
+        let col = fastfield_readers.bool("field_bool").unwrap();
+        assert_eq!(col.get_val(0), false);
     }
 
     fn get_index(docs: &[crate::Document], schema: &Schema) -> crate::Result<RamDirectory> {
@@ -898,13 +893,13 @@ mod tests {
         let directory = get_index(&docs[..], &schema)?;
         let path = Path::new("test");
         let file = directory.open_read(path).unwrap();
-        let composite_file = CompositeFile::open(&file)?;
-        let file = composite_file.open_read(*FIELD).unwrap();
         let len = file.len();
-        let test_fastfield = open::<DateTime>(file.read_bytes()?)?;
+        let readers = FastFieldReaders::open(file).unwrap();
+        let col = readers.datetime("field").unwrap();
 
         for (i, time) in times.iter().enumerate() {
-            assert_eq!(test_fastfield.get_val(i as u32), time.truncate(precision));
+            let dt: crate::DateTime = col.get_val(i as u32).into();
+            assert_eq!(dt, time.truncate(precision));
         }
         Ok(len)
     }
diff --git a/src/fastfield/readers.rs b/src/fastfield/readers.rs
index 701de4a56..35aa00473 100644
--- a/src/fastfield/readers.rs
+++ b/src/fastfield/readers.rs
@@ -33,7 +33,7 @@ impl FastFieldReaders {
     }
 
     // TODO make opt
-    pub fn typed_column<T>(&self, field: &str) -> crate::Result<columnar::Column<T>>
+    pub fn typed_column_opt<T>(&self, field: &str) -> crate::Result<Option<columnar::Column<T>>>
     where
         T: PartialOrd + Copy + HasAssociatedColumnType + Send + Sync + Default + 'static,
         DynamicColumn: Into<Option<columnar::Column<T>>>,
@@ -44,13 +44,10 @@ impl FastFieldReaders {
             .filter(|column| column.column_type() == column_type)
             .next() else {
             // TODO Option would make more sense.
-            return Err(crate::TantivyError::SchemaError(format!("No fast field of with this name")));
+            return Ok(None);
         };
         let dynamic_column = dynamic_column_handle.open()?;
-        let col: columnar::Column<T> = dynamic_column
-            .into()
-            .ok_or_else(|| crate::TantivyError::SchemaError(format!("Invalid type")))?;
-        Ok(col)
+        Ok(dynamic_column.into())
     }
 
     pub fn typed_column_first_or_default<T>(&self, field: &str) -> crate::Result<Arc<dyn Column<T>>>
@@ -58,8 +55,12 @@ impl FastFieldReaders {
         T: PartialOrd + Copy + HasAssociatedColumnType + Send + Sync + Default + 'static,
         DynamicColumn: Into<Option<columnar::Column<T>>>,
     {
-        let col = self.typed_column(field)?;
-        Ok(col.first_or_default_col(T::default()))
+        let col_opt = self.typed_column_opt(field)?;
+        if let Some(col) = col_opt {
+            Ok(col.first_or_default_col(T::default()))
+        } else {
+            todo!();
+        }
     }
 
     /// Returns the `u64` fast field reader reader associated with `field`.
@@ -69,6 +70,12 @@ impl FastFieldReaders {
         self.typed_column_first_or_default(field)
     }
 
+    pub fn datetime(&self, field: &str) -> crate::Result<Arc<dyn ColumnValues<columnar::DateTime>>> {
+        self.typed_column_first_or_default(field)
+    }
+
+
+
     /// Returns the `ip` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a u128 fast field, this method returns an Error.