we are passing all the tests now properly with the table definition and the post tables data now

server/src/table_definition/handlers/post_table_definition.rs

@@ -56,6 +56,53 @@ fn validate_identifier_format(s: &str, identifier_type: &str) -> Result<(), Stat
     Ok(())
 }
 
+fn validate_decimal_number_format(num_str: &str, param_name: &str) -> Result<(), Status> {
+    if num_str.is_empty() {
+        return Err(Status::invalid_argument(format!(
+            "{} cannot be empty",
+            param_name
+        )));
+    }
+
+    // Check for explicit signs
+    if num_str.starts_with('+') || num_str.starts_with('-') {
+        return Err(Status::invalid_argument(format!(
+            "{} cannot have explicit positive or negative signs",
+            param_name
+        )));
+    }
+
+    // Check for decimal points
+    if num_str.contains('.') {
+        return Err(Status::invalid_argument(format!(
+            "{} must be a whole number (no decimal points)",
+            param_name
+        )));
+    }
+
+    // Check for leading zeros (but allow "0" itself)
+    if num_str.len() > 1 && num_str.starts_with('0') {
+        let trimmed = num_str.trim_start_matches('0');
+        let suggestion = if trimmed.is_empty() { "0" } else { trimmed };
+        return Err(Status::invalid_argument(format!(
+            "{} cannot have leading zeros (use '{}' instead of '{}')",
+            param_name,
+            suggestion,
+            num_str
+        )));
+    }
+
+    // Check that all characters are digits
+    if !num_str.chars().all(|c| c.is_ascii_digit()) {
+        return Err(Status::invalid_argument(format!(
+            "{} contains invalid characters. Only digits 0-9 are allowed",
+            param_name
+        )));
+    }
+
+    Ok(())
+}
+
 fn map_field_type(field_type: &str) -> Result<String, Status> {
     let lower_field_type = field_type.to_lowercase();
 
@@ -69,13 +116,20 @@ fn map_field_type(field_type: &str) -> Result<String, Status> {
 
         // Split into precision and scale parts
         if let Some((p_str, s_str)) = args.split_once(',') {
+            let precision_str = p_str.trim();
+            let scale_str = s_str.trim();
+
+            // NEW: Validate format BEFORE parsing
+            validate_decimal_number_format(precision_str, "precision")?;
+            validate_decimal_number_format(scale_str, "scale")?;
+
             // Parse precision, returning an error if it's not a valid number
-            let precision = p_str.trim().parse::<u32>().map_err(|_| {
+            let precision = precision_str.parse::<u32>().map_err(|_| {
                 Status::invalid_argument("Invalid precision in decimal type")
             })?;
 
             // Parse scale, returning an error if it's not a valid number
-            let scale = s_str.trim().parse::<u32>().map_err(|_| {
+            let scale = scale_str.parse::<u32>().map_err(|_| {
                 Status::invalid_argument("Invalid scale in decimal type")
             })?;