use std::sync::Arc;
use std::time::Duration;
use serde::Serialize;
use serde::de::DeserializeOwned;
use serde_json::Value;
use tokio::sync::mpsc::UnboundedSender;
use crate::bucket::BucketOps;
use crate::config::SurrealConfig;
use crate::error::{SurrealError, SurrealResult};
use crate::query::{QueryBuilder, send_command, send_command_void};
use crate::router::{self, RouterCommand};
#[derive(Clone)]
pub struct SurrealClient {
inner: Arc<ClientInner>,
}
impl std::fmt::Debug for SurrealClient {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SurrealClient")
.field("namespace", &self.inner.config.namespace)
.field("database", &self.inner.config.database)
.field("url", &self.inner.config.url)
.finish()
}
}
struct ClientInner {
request_tx: UnboundedSender<RouterCommand>,
#[allow(dead_code)]
config: SurrealConfig,
query_timeout: Duration,
_router_handle: Arc<tokio::task::JoinHandle<()>>,
}
impl SurrealClient {
pub async fn connect(config: SurrealConfig) -> SurrealResult<Self> {
config.validate()?;
let query_timeout = config.query_timeout;
let (request_tx, request_rx) = router::router_channel();
let handle = router::spawn_router(request_rx, config.clone());
let client = Self {
inner: Arc::new(ClientInner {
request_tx: request_tx.clone(),
config: config.clone(),
query_timeout,
_router_handle: Arc::new(handle),
}),
};
match client.health().await {
Ok(()) => Ok(client),
Err(e) => {
log::warn!("[surreal] 初始 health check 失败: {e}, 等待重连后重试...");
tokio::time::sleep(Duration::from_millis(200)).await;
client.health().await?;
Ok(client)
}
}
}
pub async fn health(&self) -> SurrealResult<()> {
send_command_void(
&self.inner.request_tx,
"ping",
serde_json::json!([]),
self.inner.query_timeout,
)
.await
}
pub async fn version(&self) -> SurrealResult<String> {
let result = send_command(
&self.inner.request_tx,
"version",
serde_json::json!([]),
self.inner.query_timeout,
)
.await?;
match result {
Value::String(s) => Ok(s),
_ => Ok(result.to_string()),
}
}
pub async fn set(&self, key: &str, value: &(impl Serialize + ?Sized)) -> SurrealResult<()> {
let v = serde_json::to_value(value).map_err(SurrealError::SerializationFailed)?;
let params = crate::protocol::set_params(key, &v);
send_command_void(
&self.inner.request_tx,
"let",
params,
self.inner.query_timeout,
)
.await
}
pub async fn unset(&self, key: &str) -> SurrealResult<()> {
send_command_void(
&self.inner.request_tx,
"unset",
serde_json::json!([key]),
self.inner.query_timeout,
)
.await
}
pub fn query(&self, sql: impl Into<String>) -> QueryBuilder<'_> {
QueryBuilder {
request_tx: self.inner.request_tx.clone(),
sql: sql.into(),
bindings: Default::default(),
query_timeout: self.inner.query_timeout,
bind_error: None,
_phantom: std::marker::PhantomData,
}
}
pub fn transaction(&self, statements: &[&str]) -> QueryBuilder<'_> {
let mut sql = String::from("BEGIN TRANSACTION;");
for stmt in statements {
sql.push_str(stmt);
if !stmt.ends_with(';') {
sql.push(';');
}
}
sql.push_str("COMMIT TRANSACTION;");
self.query(sql)
}
pub fn bucket(&self, name: impl Into<String>) -> BucketOps<'_> {
BucketOps {
request_tx: self.inner.request_tx.clone(),
bucket_name: name.into(),
query_timeout: self.inner.query_timeout,
_phantom: std::marker::PhantomData,
}
}
pub async fn create(&self, table: &str, data: &impl Serialize) -> SurrealResult<Value> {
let json_data = serde_json::to_value(data).map_err(SurrealError::SerializationFailed)?;
let sql = format!("CREATE {table} CONTENT $data");
self.query(&sql)
.bind("data", &json_data)
.raw()
.await
.map(|mut r| {
r.first_mut()
.map(|q| std::mem::take(&mut q.result))
.unwrap_or(Value::Null)
})
}
pub async fn select<T: DeserializeOwned>(
&self,
table: &str,
id: &str,
) -> SurrealResult<Option<T>> {
let sql = format!("SELECT * FROM {table}:`{id}`");
self.query(&sql).one().await
}
pub async fn update(
&self,
table: &str,
id: &str,
data: &impl Serialize,
) -> SurrealResult<Option<Value>> {
let json_data = serde_json::to_value(data).map_err(SurrealError::SerializationFailed)?;
let sql = format!("UPDATE {table}:`{id}` MERGE $data RETURN AFTER");
self.query(&sql)
.bind("data", &json_data)
.raw()
.await
.map(|mut r| {
r.first_mut()
.map(|q| std::mem::take(&mut q.result))
.unwrap_or(Value::Null)
})
.map(Some)
}
pub async fn upsert(
&self,
table: &str,
id: &str,
data: &impl Serialize,
) -> SurrealResult<Value> {
let json_data = serde_json::to_value(data).map_err(SurrealError::SerializationFailed)?;
let sql = format!("UPSERT {table}:`{id}` CONTENT $data");
self.query(&sql)
.bind("data", &json_data)
.raw()
.await
.map(|mut r| {
r.first_mut()
.map(|q| std::mem::take(&mut q.result))
.unwrap_or(Value::Null)
})
}
pub async fn delete(&self, table: &str, id: &str) -> SurrealResult<Option<Value>> {
let sql = format!("DELETE {table}:`{id}` RETURN BEFORE");
self.query(&sql)
.raw()
.await
.map(|mut r| r.first_mut().map(|q| std::mem::take(&mut q.result)))
}
}