Only supporting generated columns with valid string expressions

crates/modelardb_storage/src/lib.rs

@@ -454,11 +454,8 @@ fn generated_columns_to_list_array(generated_columns: Vec<Option<GeneratedColumn
 
     for generated_column in generated_columns {
         if let Some(generated_column) = generated_column {
-            if let Some(sql_expr) = generated_column.original_expr {
-                generated_columns_builder.values().append_value(sql_expr);
-            } else {
-                generated_columns_builder.values().append_null();
-            }
+            let sql_expr = generated_column.original_expr;
+            generated_columns_builder.values().append_value(sql_expr);
         } else {
             generated_columns_builder.values().append_null();
         }

crates/modelardb_storage/src/metadata/model_table_metadata.rs

@@ -216,7 +216,7 @@ pub struct GeneratedColumn {
     pub source_columns: Vec<usize>,
     /// Original representation of `expr`. It is copied from the SQL statement, so it can be stored
     /// in the metadata Delta Lake as `expr` does not implement serialization and deserialization.
-    pub original_expr: Option<String>,
+    pub original_expr: String,
 }
 
 impl GeneratedColumn {
@@ -235,7 +235,7 @@ impl GeneratedColumn {
         Ok(Self {
             expr,
             source_columns: source_columns?,
-            original_expr: Some(sql_expr.to_owned()),
+            original_expr: sql_expr.to_owned(),
         })
     }
 }
@@ -371,7 +371,7 @@ mod test {
                 options: wild_card_options.clone(),
             },
             source_columns: vec![],
-            original_expr: None,
+            original_expr: "".to_owned(),
         });
 
         generated_columns[6] = Some(GeneratedColumn {
@@ -380,7 +380,7 @@ mod test {
                 options: wild_card_options,
             },
             source_columns: vec![5],
-            original_expr: None,
+            original_expr: "".to_owned(),
         });
 
         let result = ModelTableMetadata::try_new(
@@ -486,7 +486,7 @@ mod test {
         let expected_generated_column = GeneratedColumn {
             expr: col("field_1") + col("field_2"),
             source_columns: vec![0, 1],
-            original_expr: Some(sql_expr.to_owned()),
+            original_expr: sql_expr.to_owned(),
         };
 
         let df_schema = schema.to_dfschema().unwrap();

crates/modelardb_storage/src/metadata/table_metadata_manager.rs

@@ -382,13 +382,10 @@ impl TableMetadataManager {
             .enumerate()
         {
             if model_table_metadata.is_field(query_schema_index) {
-                let generated_column_expr = if let Some(generated_column) =
-                    &model_table_metadata.generated_columns[query_schema_index]
-                {
-                    generated_column.original_expr.clone()
-                } else {
-                    None
-                };
+                let maybe_generated_column_expr = model_table_metadata.generated_columns
+                    [query_schema_index]
+                    .as_ref()
+                    .map(|generated_column| generated_column.original_expr.clone());
 
                 // error_bounds matches schema and not query_schema to simplify looking up the error
                 // bound during ingestion as it occurs far more often than creation of model tables.
@@ -412,7 +409,7 @@ impl TableMetadataManager {
                             Arc::new(Int16Array::from(vec![query_schema_index as i16])),
                             Arc::new(Float32Array::from(vec![error_bound_value])),
                             Arc::new(BooleanArray::from(vec![error_bound_is_relative])),
-                            Arc::new(StringArray::from(vec![generated_column_expr])),
+                            Arc::new(StringArray::from(vec![maybe_generated_column_expr])),
                         ],
                     )
                     .await?;
@@ -1388,13 +1385,13 @@ mod tests {
         let plus_one_column = Some(GeneratedColumn {
             expr: col("field_1") + Literal(Int64(Some(1))),
             source_columns: vec![1],
-            original_expr: Some("field_1 + 1".to_owned()),
+            original_expr: "field_1 + 1".to_owned(),
         });
 
         let addition_column = Some(GeneratedColumn {
             expr: col("field_1") + col("field_2"),
             source_columns: vec![1, 2],
-            original_expr: Some("field_1 + field_2".to_owned()),
+            original_expr: "field_1 + field_2".to_owned(),
         });
 
         let expected_generated_columns =

crates/modelardb_storage/src/parser.rs

@@ -979,7 +979,7 @@ fn extract_generation_exprs_for_all_columns(
                 // Lake, it is not stored in ModelTableMetadata as it not used for during query
                 // execution.
                 let sql_expr = generation_expr.as_ref().unwrap();
-                let original_expr = Some(sql_expr.to_string());
+                let original_expr = sql_expr.to_string();
 
                 // Ensure that the parsed sqlparser expression can be converted to a logical Apache
                 // Arrow DataFusion expression within the context of schema to check it for errors.