Add option for fieldnorm

Signed-off-by: Mehul Arora <aroram18@mcmaster.ca>

quickwit-doc-mapper/src/default_doc_mapper/field_mapping_entry.rs

@@ -486,6 +486,8 @@ struct FieldMappingEntryForSerialization {
     #[serde(skip_serializing_if = "Option::is_none")]
     indexed: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    fieldnorms: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     tokenizer: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     record: Option<IndexRecordOption>,
@@ -527,6 +529,7 @@ impl From<FieldMappingEntry> for FieldMappingEntryForSerialization {
         let type_with_cardinality = value.mapping_type.type_with_cardinality();
         let mut fast = false;
         let mut indexed = None;
+        let mut fieldnorms = None;
         let mut record = None;
         let mut stored = false;
         let mut tokenizer: Option<String> = None;
@@ -538,6 +541,7 @@ impl From<FieldMappingEntry> for FieldMappingEntryForSerialization {
                     record = Some(indexing_options.index_option());
                 } else {
                     indexed = Some(false);
+                    fieldnorms = Some(false);
                 }
             }
             FieldMappingType::I64(options, _)
@@ -561,6 +565,7 @@ impl From<FieldMappingEntry> for FieldMappingEntryForSerialization {
             type_with_cardinality,
             fast,
             indexed,
+            fieldnorms,
             record,
             stored,
             tokenizer,
@@ -599,10 +604,12 @@ impl FieldMappingEntryForSerialization {
             )
         }
         let mut options = TextOptions::default();
+
         if self.indexed.unwrap_or(true) {
             let mut indexing_options = TextFieldIndexing::default();
+            indexing_options = indexing_options.set_fieldnorms(self.fieldnorms.unwrap_or(false));
             if let Some(index_option) = self.record {
-                indexing_options = indexing_options.set_index_option(index_option);
+                indexing_options = indexing_options.set_index_option(index_option)
             }
             if let Some(tokenizer) = &self.tokenizer {
                 indexing_options = indexing_options.set_tokenizer(tokenizer);
@@ -649,6 +656,9 @@ impl FieldMappingEntryForSerialization {
         }
         if self.indexed.unwrap_or(true) {
             options = options.set_indexed();
+            if self.fieldnorms.unwrap_or(false) {
+                options = options.set_fieldnorms();
+            }
         }
         if self.fast {
             options = options.set_fast();
@@ -696,6 +706,9 @@ impl FieldMappingEntryForSerialization {
         }
         if self.indexed.unwrap_or(true) {
             options = options.set_indexed();
+            if self.fieldnorms.unwrap_or(false) {
+                options = options.set_fieldnorm();
+            }
         }
         Ok(options)
     }
@@ -796,6 +809,32 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_deserialize_valid_fieldnorms() -> anyhow::Result<()> {
+        let result = serde_json::from_str::<FieldMappingEntry>(
+            r#"
+        {
+            "name": "my_field_name",
+            "type": "text",
+            "stored": true,
+            "indexed": true,
+            "fieldnorms": true,
+            "record": "basic",
+            "tokenizer": "english"
+        }"#,
+        );
+        match result.unwrap().mapping_type {
+            FieldMappingType::Text(options, _) => {
+                assert_eq!(options.is_stored(), true);
+                let index_options = options.get_indexing_options().unwrap();
+                assert_eq!(index_options.fieldnorms(), true);
+            }
+            _ => panic!("wrong property type"),
+        }
+
+        Ok(())
+    }
+
     #[test]
     fn test_error_on_text_with_invalid_options() -> anyhow::Result<()> {
         let result = serde_json::from_str::<FieldMappingEntry>(
@@ -938,6 +977,7 @@ mod tests {
         match result.mapping_type {
             FieldMappingType::I64(options, cardinality) => {
                 assert_eq!(options.is_indexed(), true); // default
+                assert_eq!(options.fieldnorms(), false); // default
                 assert_eq!(options.is_fast(), false); // default
                 assert_eq!(options.is_stored(), true); // default
                 assert_eq!(cardinality, Cardinality::MultiValues);