fix(query): preserve integers beyond 64 bits in result serialization

Closes #9310
This commit is contained in:
t8y2 committed 2026-09-17 20:13:04 +08:00
1 parent 6b81a98453
commit 3b4f46253c
2 files changed
+100

No files matched your search

+54
View File
@@ -6071,6 +6071,60 @@ mod tests {
);
}
#[test]
fn prepares_oracle_number28_updates_from_serialized_query_results() {
let identifiers = ["2026081810175800100000000000", "2026081810175800100000000001"];
let rows: Vec<Vec<Value>> = 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::<Vec<_>>()
);
}
#[test]
fn prepares_sqlserver_bigint_update_from_numeric_string() {
let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+46
View File
@@ -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::<Vec<_>>());
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();