use crate::error::BaseError;
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(transparent)]
#[schemars(transparent)]
pub struct Record {
columns: serde_json::Map<String, serde_json::Value>,
}
impl Record {
pub fn new() -> Self {
Self {
columns: serde_json::Map::new(),
}
}
pub fn set(mut self, key: impl Into<String>, value: impl Into<serde_json::Value>) -> Self {
self.columns.insert(key.into(), value.into());
self
}
pub fn insert(
&mut self,
key: impl Into<String>,
value: impl Into<serde_json::Value>,
) -> Option<serde_json::Value> {
self.columns.insert(key.into(), value.into())
}
pub fn get(&self, key: &str) -> Option<&serde_json::Value> {
if key.trim().is_empty() {
return None;
}
self.columns.get(key)
}
pub fn require<T>(&self, key: &str) -> Result<T, BaseError>
where
T: DeserializeOwned,
{
let value = self
.get(key)
.ok_or_else(|| BaseError::FieldNotFound("record".to_string(), key.to_string()))?;
serde_json::from_value(value.clone())
.map_err(|error| BaseError::InvalidFieldType(key.to_string(), error.to_string()))
}
pub fn optional<T>(&self, key: &str) -> Result<Option<T>, BaseError>
where
T: DeserializeOwned,
{
let Some(value) = self.get(key) else {
return Ok(None);
};
if value.is_null() {
return Ok(None);
}
serde_json::from_value(value.clone())
.map(Some)
.map_err(|error| BaseError::InvalidFieldType(key.to_string(), error.to_string()))
}
pub fn as_map(&self) -> &serde_json::Map<String, serde_json::Value> {
&self.columns
}
pub fn into_map(self) -> serde_json::Map<String, serde_json::Value> {
self.columns
}
#[cfg(feature = "mysql")]
pub(crate) fn into_columns(self) -> std::collections::HashMap<String, serde_json::Value> {
self.columns.into_iter().collect()
}
}
impl Default for Record {
fn default() -> Self {
Self::new()
}
}
impl From<serde_json::Map<String, serde_json::Value>> for Record {
fn from(columns: serde_json::Map<String, serde_json::Value>) -> Self {
Self { columns }
}
}
impl From<Record> for serde_json::Value {
fn from(row: Record) -> Self {
serde_json::Value::Object(row.columns)
}
}
#[cfg(feature = "mysql")]
impl<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> for Record {
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(Record { 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 = Record::new();
row.insert("", json!(1));
row.insert(" ", json!(2));
row.insert("name", 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);
}
#[test]
fn serializes_as_plain_object_and_checks_types() {
let row = Record::new().set("id", 7).set("name", "Alice");
assert_eq!(
serde_json::to_value(&row).expect("记录应可序列化"),
json!({
"id": 7,
"name": "Alice"
})
);
assert_eq!(row.require::<i64>("id").expect("id 应为整数"), 7);
assert!(row.require::<String>("id").is_err());
assert!(row.require::<String>("missing").is_err());
}
}