use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DynamicRow {
pub columns: serde_json::Map<String, serde_json::Value>,
}
impl DynamicRow {
pub fn new() -> Self {
Self {
columns: serde_json::Map::new(),
}
}
pub fn get(&self, key: &str) -> Option<&serde_json::Value> {
if key.trim().is_empty() {
return None;
}
self.columns.get(key)
}
}
impl Default for DynamicRow {
fn default() -> Self {
Self::new()
}
}
impl From<DynamicRow> for serde_json::Value {
fn from(row: DynamicRow) -> Self {
serde_json::Value::Object(row.columns)
}
}
#[cfg(feature = "mysql")]
impl<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> for DynamicRow {
fn from_row(row: &'r sqlx::mysql::MySqlRow) -> Result<Self, sqlx::Error> {
use sqlx::Column;
use sqlx::Row;
use sqlx::TypeInfo;
use sqlx::ValueRef;
let mut columns = serde_json::Map::new();
for col in row.columns() {
let col_name = col.name().to_string();
let type_name = col.type_info().name().to_uppercase();
let is_null: bool = row
.try_get_raw(col.ordinal())
.map(|v| v.is_null())
.unwrap_or(false);
if is_null {
columns.insert(col_name, serde_json::Value::Null);
continue;
}
let json_value = decode_mysql_column(row, col.ordinal(), &type_name)?;
columns.insert(col_name, json_value);
}
Ok(DynamicRow { columns })
}
}
#[cfg(feature = "mysql")]
fn decode_mysql_column(
row: &sqlx::mysql::MySqlRow,
ordinal: usize,
type_name: &str,
) -> Result<serde_json::Value, sqlx::Error> {
use base64::Engine;
use sqlx::Row;
if type_name.contains("INT") && !type_name.contains("TINYINT") {
let val: i64 = row.try_get(ordinal)?;
return Ok(serde_json::Value::Number(val.into()));
}
if type_name == "BOOLEAN" || type_name == "TINYINT" {
let val: i8 = row.try_get(ordinal)?;
return Ok(serde_json::Value::Bool(val != 0));
}
if type_name == "DECIMAL" || type_name == "NUMERIC" {
let val: String = row.try_get_unchecked(ordinal)?;
return Ok(serde_json::Value::String(val));
}
if type_name == "FLOAT" || type_name == "DOUBLE" {
let val: f64 = row.try_get(ordinal)?;
let json_num = serde_json::Number::from_f64(val).ok_or_else(|| {
sqlx::Error::Decode("浮点数值为 NaN 或 Infinity 无法编码为 JSON Number".into())
})?;
return Ok(serde_json::Value::Number(json_num));
}
if type_name == "DATE" {
let val: chrono::NaiveDate = row.try_get(ordinal)?;
return Ok(serde_json::Value::String(
val.format("%Y-%m-%d").to_string(),
));
}
if type_name == "DATETIME" || type_name == "TIMESTAMP" {
let val: chrono::NaiveDateTime = row.try_get(ordinal)?;
return Ok(serde_json::Value::String(
val.format("%Y-%m-%dT%H:%M:%S").to_string(),
));
}
if type_name == "TIME" {
let val: chrono::NaiveTime = row.try_get(ordinal)?;
return Ok(serde_json::Value::String(
val.format("%H:%M:%S").to_string(),
));
}
if type_name.contains("BLOB") || type_name.contains("BINARY") {
let val: Vec<u8> = row.try_get(ordinal)?;
let encoded = base64::engine::general_purpose::STANDARD.encode(&val);
return Ok(serde_json::Value::String(encoded));
}
if type_name == "JSON" {
let val: serde_json::Value = row.try_get(ordinal)?;
return Ok(val);
}
let val: String = row.try_get(ordinal)?;
Ok(serde_json::Value::String(val))
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn get_rejects_blank_column_name() {
let mut row = DynamicRow::new();
row.columns.insert("".to_string(), json!(1));
row.columns.insert(" ".to_string(), json!(2));
row.columns.insert("name".to_string(), json!("Alice"));
assert_eq!(
row.get("name").and_then(|value| value.as_str()),
Some("Alice")
);
assert_eq!(row.get(""), None);
assert_eq!(row.get(" "), None);
}
}