yang_base/table/
record.rs1use crate::error::BaseError;
36use serde::de::DeserializeOwned;
37use serde::{Deserialize, Serialize};
38
39#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, schemars::JsonSchema)]
59#[serde(transparent)]
60#[schemars(transparent)]
61pub struct Record {
62 columns: serde_json::Map<String, serde_json::Value>,
63}
64
65impl Record {
66 pub fn new() -> Self {
68 Self {
69 columns: serde_json::Map::new(),
70 }
71 }
72
73 pub fn set(mut self, key: impl Into<String>, value: impl Into<serde_json::Value>) -> Self {
75 self.columns.insert(key.into(), value.into());
76 self
77 }
78
79 pub fn insert(
81 &mut self,
82 key: impl Into<String>,
83 value: impl Into<serde_json::Value>,
84 ) -> Option<serde_json::Value> {
85 self.columns.insert(key.into(), value.into())
86 }
87
88 pub fn get(&self, key: &str) -> Option<&serde_json::Value> {
99 if key.trim().is_empty() {
100 return None;
101 }
102
103 self.columns.get(key)
104 }
105
106 pub fn require<T>(&self, key: &str) -> Result<T, BaseError>
108 where
109 T: DeserializeOwned,
110 {
111 let value = self
112 .get(key)
113 .ok_or_else(|| BaseError::FieldNotFound("record".to_string(), key.to_string()))?;
114 serde_json::from_value(value.clone())
115 .map_err(|error| BaseError::InvalidFieldType(key.to_string(), error.to_string()))
116 }
117
118 pub fn optional<T>(&self, key: &str) -> Result<Option<T>, BaseError>
120 where
121 T: DeserializeOwned,
122 {
123 let Some(value) = self.get(key) else {
124 return Ok(None);
125 };
126 if value.is_null() {
127 return Ok(None);
128 }
129 serde_json::from_value(value.clone())
130 .map(Some)
131 .map_err(|error| BaseError::InvalidFieldType(key.to_string(), error.to_string()))
132 }
133
134 pub fn as_map(&self) -> &serde_json::Map<String, serde_json::Value> {
136 &self.columns
137 }
138
139 pub fn into_map(self) -> serde_json::Map<String, serde_json::Value> {
141 self.columns
142 }
143
144 #[cfg(feature = "mysql")]
146 pub(crate) fn into_columns(self) -> std::collections::HashMap<String, serde_json::Value> {
147 self.columns.into_iter().collect()
148 }
149}
150
151impl Default for Record {
152 fn default() -> Self {
153 Self::new()
154 }
155}
156
157impl From<serde_json::Map<String, serde_json::Value>> for Record {
158 fn from(columns: serde_json::Map<String, serde_json::Value>) -> Self {
159 Self { columns }
160 }
161}
162
163impl From<Record> for serde_json::Value {
165 fn from(row: Record) -> Self {
166 serde_json::Value::Object(row.columns)
167 }
168}
169
170#[cfg(feature = "mysql")]
185impl<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> for Record {
186 fn from_row(row: &'r sqlx::mysql::MySqlRow) -> Result<Self, sqlx::Error> {
187 use sqlx::Column;
188 use sqlx::Row;
189 use sqlx::TypeInfo;
190 use sqlx::ValueRef;
191
192 let mut columns = serde_json::Map::new();
193
194 for col in row.columns() {
196 let col_name = col.name().to_string();
197 let type_name = col.type_info().name().to_uppercase();
198
199 let is_null: bool = row
201 .try_get_raw(col.ordinal())
202 .map(|v| v.is_null())
203 .unwrap_or(false);
204
205 if is_null {
206 columns.insert(col_name, serde_json::Value::Null);
208 continue;
209 }
210
211 let json_value = decode_mysql_column(row, col.ordinal(), &type_name)?;
213 columns.insert(col_name, json_value);
214 }
215
216 Ok(Record { columns })
217 }
218}
219
220#[cfg(feature = "mysql")]
226#[derive(Debug, Clone, Copy, PartialEq, Eq)]
227enum MysqlIntegerKind {
228 Int64,
230 Boolean,
232 TinyInt,
234 TinyIntUnsigned,
236 Other,
238}
239
240#[cfg(feature = "mysql")]
242fn mysql_integer_kind(type_name: &str) -> MysqlIntegerKind {
243 if type_name.contains("INT") && !type_name.contains("TINYINT") {
245 return MysqlIntegerKind::Int64;
246 }
247 match type_name {
248 "BOOLEAN" => MysqlIntegerKind::Boolean,
250 "TINYINT" => MysqlIntegerKind::TinyInt,
251 "TINYINT UNSIGNED" => MysqlIntegerKind::TinyIntUnsigned,
252 _ => MysqlIntegerKind::Other,
253 }
254}
255
256#[cfg(feature = "mysql")]
269fn decode_mysql_column(
270 row: &sqlx::mysql::MySqlRow,
271 ordinal: usize,
272 type_name: &str,
273) -> Result<serde_json::Value, sqlx::Error> {
274 use base64::Engine;
275 use sqlx::Row;
276
277 match mysql_integer_kind(type_name) {
278 MysqlIntegerKind::Int64 => {
280 let val: i64 = row.try_get(ordinal)?;
281 return Ok(serde_json::Value::Number(val.into()));
282 }
283 MysqlIntegerKind::Boolean => {
286 let val: i8 = row.try_get(ordinal)?;
287 return Ok(serde_json::Value::Bool(val != 0));
288 }
289 MysqlIntegerKind::TinyInt => {
291 let val: i8 = row.try_get(ordinal)?;
292 return Ok(serde_json::Value::Number(i64::from(val).into()));
293 }
294 MysqlIntegerKind::TinyIntUnsigned => {
296 let val: u8 = row.try_get(ordinal)?;
297 return Ok(serde_json::Value::Number(u64::from(val).into()));
298 }
299 MysqlIntegerKind::Other => {}
300 }
301
302 if type_name == "DECIMAL" || type_name == "NUMERIC" {
305 let val: String = row.try_get_unchecked(ordinal)?;
306 return Ok(serde_json::Value::String(val));
307 }
308
309 if type_name == "FLOAT" || type_name == "DOUBLE" {
311 let val: f64 = row.try_get(ordinal)?;
312 let json_num = serde_json::Number::from_f64(val).ok_or_else(|| {
314 sqlx::Error::Decode("浮点数值为 NaN 或 Infinity 无法编码为 JSON Number".into())
315 })?;
316 return Ok(serde_json::Value::Number(json_num));
317 }
318
319 if type_name == "DATE" {
321 let val: chrono::NaiveDate = row.try_get(ordinal)?;
322 return Ok(serde_json::Value::String(
324 val.format("%Y-%m-%d").to_string(),
325 ));
326 }
327
328 if type_name == "DATETIME" || type_name == "TIMESTAMP" {
329 let val: chrono::NaiveDateTime = row.try_get(ordinal)?;
330 return Ok(serde_json::Value::String(
332 val.format("%Y-%m-%dT%H:%M:%S").to_string(),
333 ));
334 }
335
336 if type_name == "TIME" {
337 let val: chrono::NaiveTime = row.try_get(ordinal)?;
338 return Ok(serde_json::Value::String(
339 val.format("%H:%M:%S").to_string(),
340 ));
341 }
342
343 if type_name.contains("BLOB") || type_name.contains("BINARY") {
345 let val: Vec<u8> = row.try_get(ordinal)?;
346 let encoded = base64::engine::general_purpose::STANDARD.encode(&val);
348 return Ok(serde_json::Value::String(encoded));
349 }
350
351 if type_name == "JSON" {
353 let val: serde_json::Value = row.try_get(ordinal)?;
354 return Ok(val);
355 }
356
357 let val: String = row.try_get(ordinal)?;
360 Ok(serde_json::Value::String(val))
361}
362
363#[cfg(test)]
364mod tests {
365 use super::*;
366 use serde_json::json;
367
368 #[test]
369 fn get_rejects_blank_column_name() {
370 let mut row = Record::new();
371 row.insert("", json!(1));
372 row.insert(" ", json!(2));
373 row.insert("name", json!("Alice"));
374
375 assert_eq!(
376 row.get("name").and_then(|value| value.as_str()),
377 Some("Alice")
378 );
379 assert_eq!(row.get(""), None);
380 assert_eq!(row.get(" "), None);
381 }
382
383 #[test]
384 fn serializes_as_plain_object_and_checks_types() {
385 let row = Record::new().set("id", 7).set("name", "Alice");
386
387 assert_eq!(
388 serde_json::to_value(&row).expect("记录应可序列化"),
389 json!({
390 "id": 7,
391 "name": "Alice"
392 })
393 );
394 assert_eq!(row.require::<i64>("id").expect("id 应为整数"), 7);
395 assert!(row.require::<String>("id").is_err());
396 assert!(row.require::<String>("missing").is_err());
397 }
398
399 #[cfg(feature = "mysql")]
400 #[test]
401 fn mysql_integer_kind_distinguishes_boolean_tinyint_and_unsigned() {
402 assert_eq!(mysql_integer_kind("BOOLEAN"), MysqlIntegerKind::Boolean);
404 assert_eq!(mysql_integer_kind("TINYINT"), MysqlIntegerKind::TinyInt);
405 assert_eq!(
406 mysql_integer_kind("TINYINT UNSIGNED"),
407 MysqlIntegerKind::TinyIntUnsigned
408 );
409 assert_eq!(mysql_integer_kind("INT"), MysqlIntegerKind::Int64);
410 assert_eq!(mysql_integer_kind("INT UNSIGNED"), MysqlIntegerKind::Int64);
411 assert_eq!(mysql_integer_kind("BIGINT"), MysqlIntegerKind::Int64);
412 assert_eq!(mysql_integer_kind("MEDIUMINT"), MysqlIntegerKind::Int64);
413 assert_eq!(mysql_integer_kind("SMALLINT"), MysqlIntegerKind::Int64);
414 assert_eq!(mysql_integer_kind("VARCHAR"), MysqlIntegerKind::Other);
415 }
416}