diff --git a/crates/dbx-core/src/data_grid_sql.rs b/crates/dbx-core/src/data_grid_sql.rs index e44dd43d42..81f4988ab4 100644 --- a/crates/dbx-core/src/data_grid_sql.rs +++ b/crates/dbx-core/src/data_grid_sql.rs @@ -6071,6 +6071,60 @@ mod tests { ); } + #[test] + fn prepares_oracle_number28_updates_from_serialized_query_results() { + let identifiers = ["2026081810175800100000000000", "2026081810175800100000000001"]; + let rows: Vec> = identifiers + .iter() + .map(|identifier| vec![serde_json::from_str(identifier).unwrap(), json!("old")]) + .collect(); + let query_result: crate::types::QueryResult = serde_json::from_value(json!({ + "columns": ["ID", "NAME"], + "column_types": ["NUMBER(28)", "VARCHAR2(20)"], + "rows": rows, + "affected_rows": 0, + "execution_time_ms": 0, + })) + .unwrap(); + let wire = serde_json::to_string(&query_result).unwrap(); + let deserialized: crate::types::QueryResult = serde_json::from_str(&wire).unwrap(); + + for (row, identifier) in deserialized.rows.iter().zip(identifiers) { + assert_eq!(row[0], json!(identifier)); + } + + let result = prepare_data_grid_save(DataGridSaveStatementOptions { + database_type: Some(DatabaseType::Oracle), + identifier_quote: Some("\"".to_string()), + table_meta: DataGridTableMeta { + catalog: None, + database: None, + schema: Some("APP".to_string()), + table_name: "ITEMS".to_string(), + primary_keys: vec!["ID".to_string()], + columns: Some(vec![ + column("ID", "NUMBER(28)", false, None), + column("NAME", "VARCHAR2(20)", true, None), + ]), + }, + columns: deserialized.columns, + source_columns: None, + rows: deserialized.rows, + dirty_rows: vec![(0, vec![(1, json!("new"))]), (1, vec![(1, json!("new"))])], + deleted_rows: vec![], + new_rows: vec![], + }); + + assert_eq!(result.validation_error, None); + assert_eq!( + result.statements, + identifiers + .iter() + .map(|identifier| format!("UPDATE \"APP\".\"ITEMS\" SET \"NAME\" = 'new' WHERE \"ID\" = {identifier};")) + .collect::>() + ); + } + #[test] fn prepares_sqlserver_bigint_update_from_numeric_string() { let result = prepare_data_grid_save(DataGridSaveStatementOptions { diff --git a/crates/dbx-core/src/types.rs b/crates/dbx-core/src/types.rs index 68c08e26c8..f302b06fab 100644 --- a/crates/dbx-core/src/types.rs +++ b/crates/dbx-core/src/types.rs @@ -554,6 +554,11 @@ impl Serialize for JsSafeCell<'_> { if value > crate::db::JS_MAX_SAFE_INTEGER as u64 { return serializer.serialize_str(&value.to_string()); } + } else { + let value = number.as_str(); + if value.bytes().all(|byte| byte == b'-' || byte.is_ascii_digit()) { + return serializer.serialize_str(value); + } } self.0.serialize(serializer) } @@ -1120,6 +1125,47 @@ mod tests { assert_eq!(row[6], serde_json::Value::Null, "null passes through"); } + #[test] + fn query_result_serializes_integers_beyond_64_bits_as_strings() { + let integers = [ + "18446744073709551616", + "18446744073709551617", + "-9223372036854775809", + "2026081810175800100000000000", + "2026081810175800100000000001", + "-2026081810175800100000000000", + "99999999999999999999999999999999999999", + ]; + let mut result = bigint_result_sample(); + result.rows = integers.iter().map(|integer| vec![serde_json::from_str(integer).unwrap()]).collect(); + let expected = serde_json::json!(integers.iter().map(|integer| vec![*integer]).collect::>()); + + assert_eq!(serde_json::to_value(&result).unwrap()["rows"], expected); + + let wire = serde_json::to_string(&result).unwrap(); + let deserialized: super::QueryResult = serde_json::from_str(&wire).unwrap(); + assert_eq!(serde_json::to_value(&deserialized.rows).unwrap(), expected); + } + + #[test] + fn query_result_serialization_matches_js_normalization_for_nested_numbers() { + let cell: serde_json::Value = serde_json::from_str( + r#"{"ids":[2026081810175800100000000000,2026081810175800100000000001],"nested":{"id":-2026081810175800100000000000},"safe":42,"decimal":123.45,"exponent":1.25e-7,"null":null,"text":"2026081810175800100000000000"}"#, + ) + .unwrap(); + let mut result = bigint_result_sample(); + result.rows = vec![vec![cell.clone()]]; + + let wire = serde_json::to_string(&result).unwrap(); + let serialized: serde_json::Value = serde_json::from_str(&wire).unwrap(); + let expected = crate::db::json_value_for_js(cell); + + assert_eq!(serialized["rows"][0][0], expected); + assert_eq!(serialized["rows"][0][0]["ids"][0], "2026081810175800100000000000"); + assert_eq!(serialized["rows"][0][0]["ids"][1], "2026081810175800100000000001"); + assert_eq!(serialized["rows"][0][0]["nested"]["id"], "-2026081810175800100000000000"); + } + #[test] fn query_result_serialization_keeps_wire_shape_and_other_fields() { let mut result = bigint_result_sample();