Add FLOAT_NEGATE function

packages/sqlite-web-core/src/database_functions/float_negate.rs

@@ -0,0 +1,137 @@
+use super::*;
+
+// Helper to negate a Rain Float hex string while keeping full precision by
+// operating on the binary representation directly.
+fn float_negate_hex_to_hex(input_hex: &str) -> Result<String, String> {
+    let trimmed = input_hex.trim();
+
+    if trimmed.is_empty() {
+        return Err("Empty string is not a valid hex number".to_string());
+    }
+
+    // Parse the input hex into a Float
+    let float_val =
+        Float::from_hex(trimmed).map_err(|e| format!("Failed to parse Float hex: {e}"))?;
+
+    // Negate the float directly to avoid any formatting or precision loss.
+    let neg_float = (-float_val).map_err(|e| format!("Failed to negate Float value: {e}"))?;
+
+    // Return as hex string
+    Ok(neg_float.as_hex())
+}
+
+// SQLite scalar function wrapper: FLOAT_NEGATE(hex_text)
+pub unsafe extern "C" fn float_negate(
+    context: *mut sqlite3_context,
+    argc: c_int,
+    argv: *mut *mut sqlite3_value,
+) {
+    if argc != 1 {
+        sqlite3_result_error(
+            context,
+            c"FLOAT_NEGATE() requires exactly 1 argument".as_ptr(),
+            -1,
+        );
+        return;
+    }
+
+    // Return early for NULL inputs using the documented type check.
+    if sqlite3_value_type(*argv) == SQLITE_NULL {
+        sqlite3_result_null(context);
+        return;
+    }
+
+    // Get the text value (now known to be non-NULL).
+    let value_ptr = sqlite3_value_text(*argv);
+
+    let value_cstr = CStr::from_ptr(value_ptr as *const c_char);
+    let value_str = match value_cstr.to_str() {
+        Ok(value_str) => value_str,
+        Err(_) => {
+            sqlite3_result_error(context, c"invalid UTF-8".as_ptr(), -1);
+            return;
+        }
+    };
+
+    match float_negate_hex_to_hex(value_str) {
+        Ok(result_hex) => {
+            if let Ok(result_cstr) = CString::new(result_hex) {
+                sqlite3_result_text(
+                    context,
+                    result_cstr.as_ptr(),
+                    result_cstr.as_bytes().len() as c_int,
+                    SQLITE_TRANSIENT(),
+                );
+            } else {
+                sqlite3_result_error(context, c"Failed to create result string".as_ptr(), -1);
+            }
+        }
+        Err(e) => match CString::new(e) {
+            Ok(error_msg) => {
+                sqlite3_result_error(context, error_msg.as_ptr(), -1);
+            }
+            Err(_) => {
+                sqlite3_result_error(
+                    context,
+                    c"Error message contained interior NUL".as_ptr(),
+                    -1,
+                );
+            }
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use wasm_bindgen_test::*;
+
+    #[wasm_bindgen_test]
+    fn test_float_negate_hex_to_hex_pos_to_neg() {
+        let pos_hex = Float::parse("1.5".to_string()).unwrap().as_hex();
+        let expected_neg_hex = Float::parse("-1.5".to_string()).unwrap().as_hex();
+        let out = float_negate_hex_to_hex(&pos_hex).unwrap();
+        assert_eq!(out, expected_neg_hex);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_float_negate_hex_to_hex_neg_to_pos() {
+        let neg_hex = Float::parse("-2.25".to_string()).unwrap().as_hex();
+        let expected_pos_hex = Float::parse("2.25".to_string()).unwrap().as_hex();
+        let out = float_negate_hex_to_hex(&neg_hex).unwrap();
+        assert_eq!(out, expected_pos_hex);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_float_negate_hex_to_hex_zero() {
+        let zero_hex = Float::parse("0".to_string()).unwrap().as_hex();
+        let expected_zero_hex = Float::parse("0".to_string()).unwrap().as_hex();
+        let out = float_negate_hex_to_hex(&zero_hex).unwrap();
+        assert_eq!(out, expected_zero_hex);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_float_negate_hex_to_hex_high_precision() {
+        let input = "300.123456789012345678";
+        let in_hex = Float::parse(input.to_string()).unwrap().as_hex();
+        let expected_hex = Float::parse(format!("-{input}")).unwrap().as_hex();
+        let out = float_negate_hex_to_hex(&in_hex).unwrap();
+        assert_eq!(out, expected_hex);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_float_negate_hex_to_hex_whitespace() {
+        let in_hex = Float::parse("10".to_string()).unwrap().as_hex();
+        let wrapped = format!("  {in_hex}  ");
+        let expected_hex = Float::parse("-10".to_string()).unwrap().as_hex();
+        let out = float_negate_hex_to_hex(&wrapped).unwrap();
+        assert_eq!(out, expected_hex);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_float_negate_hex_to_hex_invalid() {
+        assert!(float_negate_hex_to_hex("0XBADHEX").is_err());
+        assert!(float_negate_hex_to_hex("").is_err());
+        assert!(float_negate_hex_to_hex("not_hex").is_err());
+    }
+}

packages/sqlite-web-core/src/database_functions/float_sum.rs

@@ -186,16 +186,18 @@ mod tests {
     fn test_float_sum_context_add_hex_without_prefix() {
         let mut context = FloatSumContext::new();
 
-        assert!(context
-            .add_value("ffffffff0000000000000000000000000000000000000000000000000000000f")
-            .is_ok()); // 1.5
+        let one_point_five = Float::parse("1.5".to_string()).unwrap().as_hex();
+        let one_point_five_no_prefix = one_point_five.trim_start_matches("0x").to_string();
+
+        assert!(context.add_value(&one_point_five_no_prefix).is_ok()); // 1.5
         let result_hex = context.get_total_as_hex().unwrap();
         let result_decimal = Float::from_hex(&result_hex).unwrap().format().unwrap();
         assert_eq!(result_decimal, "1.5");
 
-        assert!(context
-            .add_value("fffffffe000000000000000000000000000000000000000000000000000000e1")
-            .is_ok()); // 2.25
+        let two_point_two_five = Float::parse("2.25".to_string()).unwrap().as_hex();
+        let two_point_two_five_no_prefix = two_point_two_five.trim_start_matches("0x").to_string();
+
+        assert!(context.add_value(&two_point_two_five_no_prefix).is_ok()); // 2.25
         let result_hex = context.get_total_as_hex().unwrap();
         let result_decimal = Float::from_hex(&result_hex).unwrap().format().unwrap();
         assert_eq!(result_decimal, "3.75"); // 1.5 + 2.25 = 3.75
@@ -205,12 +207,17 @@ mod tests {
     fn test_float_sum_context_add_uppercase_hex() {
         let mut context = FloatSumContext::new();
 
-        assert!(context
-            .add_value("0XFFFFFFFB0000000000000000000000000000000000000000000000000004CB2F")
-            .is_err()); // Should fail - uppercase 0X not supported
-        assert!(context
-            .add_value("0XFFFFFFFF00000000000000000000000000000000000000000000000000000069")
-            .is_err()); // Should fail - uppercase 0X not supported
+        let upper_case_bad = Float::parse("-12345.6789".to_string())
+            .unwrap()
+            .as_hex()
+            .replacen("0x", "0X", 1);
+        assert!(context.add_value(&upper_case_bad).is_err()); // Should fail - uppercase 0X not supported
+
+        let another_upper = Float::parse("1024.125".to_string())
+            .unwrap()
+            .as_hex()
+            .replacen("0x", "0X", 1);
+        assert!(context.add_value(&another_upper).is_err()); // Should fail - uppercase 0X not supported
     }
 
     #[wasm_bindgen_test]

packages/sqlite-web-core/src/database_functions/mod.rs

@@ -8,10 +8,12 @@ use std::str::FromStr;
 
 // Import the individual function modules
 mod bigint_sum;
+mod float_negate;
 mod float_sum;
 mod rain_math;
 
 use bigint_sum::*;
+use float_negate::*;
 use float_sum::*;
 
 pub use rain_math::*;
@@ -78,6 +80,26 @@ pub fn register_custom_functions(db: *mut sqlite3) -> Result<(), String> {
         return Err("Failed to register FLOAT_SUM function".to_string());
     }
 
+    // Register FLOAT_NEGATE scalar function
+    let float_negate_name = CString::new("FLOAT_NEGATE").unwrap();
+    let ret = unsafe {
+        sqlite3_create_function_v2(
+            db,
+            float_negate_name.as_ptr(),
+            1, // 1 argument
+            SQLITE_UTF8 | SQLITE_DETERMINISTIC | SQLITE_INNOCUOUS,
+            std::ptr::null_mut(),
+            Some(float_negate), // xFunc for scalar
+            None,               // No xStep
+            None,               // No xFinal
+            None,               // No destructor
+        )
+    };
+
+    if ret != SQLITE_OK {
+        return Err("Failed to register FLOAT_NEGATE function".to_string());
+    }
+
     Ok(())
 }
 
@@ -86,8 +108,6 @@ mod tests {
     use super::*;
     use wasm_bindgen_test::*;
 
-    wasm_bindgen_test_configure!(run_in_browser);
-
     #[wasm_bindgen_test]
     fn test_cstring_conversion() {
         let test_string = "test string with spaces and symbols!@#$%";

svelte-test/package.json

@@ -41,6 +41,6 @@
 	"type": "module",
 	"dependencies": {
 		"@rainlanguage/float": "^0.0.0-alpha.22",
-		"@rainlanguage/sqlite-web": "file:../pkg/rainlanguage-sqlite-web-0.0.1-alpha.0.tgz"
+		"@rainlanguage/sqlite-web": "file:../pkg/rainlanguage-sqlite-web-0.0.1-alpha.1.tgz"
 	}
 }