Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

3.5 KB
Raw Blame
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WorkerRequest {
    pub id: u64,
    #[serde(flatten)]
    pub op: WorkerOp,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "op", rename_all = "snake_case")]
pub enum WorkerOp {
    Open { path: String },
    Query { sql: String, max_rows: Option<usize> },
    Backup { dest: String },
    Restore { src: String },
    Ping,
    Close,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WorkerResponse {
    pub id: u64,
    #[serde(flatten)]
    pub body: WorkerBody,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
pub enum WorkerBody {
    // Untagged variants are tried in order. `Ok` accepts any object because all of
    // its fields are optional, so `Err` must come first or error payloads decode as success.
    Err {
        error: String,
    },
    Ok {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        columns: Option<Vec<String>>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        column_types: Option<Vec<String>>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        rows: Option<Vec<Vec<serde_json::Value>>>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        affected_rows: Option<u64>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        truncated: Option<bool>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        pong: Option<bool>,
    },
}

impl WorkerBody {
    pub fn ok() -> Self {
        Self::Ok { columns: None, column_types: None, rows: None, affected_rows: None, truncated: None, pong: None }
    }

    pub fn pong() -> Self {
        Self::Ok {
            columns: None,
            column_types: None,
            rows: None,
            affected_rows: None,
            truncated: None,
            pong: Some(true),
        }
    }

    pub fn query(
        columns: Vec<String>,
        column_types: Vec<String>,
        rows: Vec<Vec<serde_json::Value>>,
        affected_rows: u64,
        truncated: bool,
    ) -> Self {
        Self::Ok {
            columns: Some(columns),
            column_types: if column_types.iter().any(|ty| !ty.is_empty()) { Some(column_types) } else { None },
            rows: Some(rows),
            affected_rows: Some(affected_rows),
            truncated: Some(truncated),
            pong: None,
        }
    }

    pub fn err(error: impl Into<String>) -> Self {
        Self::Err { error: error.into() }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn request_roundtrip() {
        let request = WorkerRequest { id: 7, op: WorkerOp::Query { sql: "SELECT 1".into(), max_rows: Some(10) } };
        let encoded = serde_json::to_string(&request).unwrap();
        assert!(encoded.contains("\"op\":\"query\""));
        let decoded: WorkerRequest = serde_json::from_str(&encoded).unwrap();
        assert_eq!(decoded, request);
    }

    #[test]
    fn response_roundtrip_keeps_errors_distinct_from_success() {
        for body in [
            WorkerBody::err("no such table: t"),
            WorkerBody::ok(),
            WorkerBody::query(vec!["id".into()], Vec::new(), vec![vec![serde_json::json!(1)]], 0, false),
        ] {
            let encoded = serde_json::to_string(&WorkerResponse { id: 7, body: body.clone() }).unwrap();
            let decoded: WorkerResponse = serde_json::from_str(&encoded).unwrap();
            assert_eq!(decoded.body, body, "{encoded}");
        }
    }
}