use crate::mysql::condition::SqlValue;
use super::{QueryBuilder, SqlGenerator};
fn ensure_mysql_row_lock(lock: crate::RowLock) -> Result<(), crate::error::DbError> {
match lock {
crate::RowLock::NoKeyUpdate | crate::RowLock::KeyShare => {
Err(crate::error::DbError::UnsupportedOperator(format!(
"MySQL 不支持行锁模式: {}",
lock.as_sql()
)))
}
_ => Ok(()),
}
}
impl<'a> QueryBuilder<'a> {
pub fn try_to_sql(&self) -> Result<String, crate::error::DbError> {
let mut generator = SqlGenerator::new();
generator.build_select(self)?;
Ok(generator.get_sql().to_string())
}
pub(crate) fn render_for_transaction(
&self,
lock: Option<crate::RowLock>,
) -> Result<(String, Vec<SqlValue>), crate::error::DbError> {
if lock.is_some()
&& (self.distinct
|| !self.group_by.is_empty()
|| !self.having_clause.is_empty()
|| !self.unions.is_empty())
{
return Err(crate::error::DbError::InvalidArgument(
"行锁不支持 DISTINCT、GROUP BY、HAVING 或 UNION 查询".to_string(),
));
}
let mut generator = SqlGenerator::new();
generator.build_select(self)?;
if let Some(lock) = lock {
ensure_mysql_row_lock(lock)?;
generator.sql.push(' ');
generator.sql.push_str(lock.as_sql());
}
Ok((generator.sql, generator.params))
}
pub fn to_sql(&self) -> String {
match self.try_to_sql() {
Ok(sql) => sql,
Err(err) => {
if self.enable_logging {
log::warn!("生成 SELECT SQL 失败: {err}");
}
"/* SQL generation failed */".to_string()
}
}
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::expect_used)]
use super::{ensure_mysql_row_lock, QueryBuilder};
use crate::error::DbError;
fn make_sync_test_pool() -> &'static sqlx::mysql::MySqlPool {
use std::sync::OnceLock;
static RT: OnceLock<tokio::runtime::Runtime> = OnceLock::new();
static POOL: OnceLock<sqlx::mysql::MySqlPool> = OnceLock::new();
let rt = RT.get_or_init(|| {
tokio::runtime::Builder::new_multi_thread()
.enable_all()
.build()
.expect("无法创建测试用 Tokio 运行时")
});
POOL.get_or_init(|| {
rt.block_on(async {
sqlx::mysql::MySqlPoolOptions::new()
.max_connections(1)
.connect_lazy("mysql://root:111111@localhost:3306/test")
.expect("无法解析测试数据库 URL")
})
})
}
#[test]
fn postgres_only_row_locks_are_rejected_for_mysql() {
for lock in [crate::RowLock::NoKeyUpdate, crate::RowLock::KeyShare] {
match ensure_mysql_row_lock(lock) {
Err(DbError::UnsupportedOperator(message)) => {
assert!(
message.contains(lock.as_sql()),
"错误消息应指出被拒绝的行锁: {message}"
);
}
other => panic!("{lock:?} 在 MySQL 下必须返回 UnsupportedOperator: {other:?}"),
}
}
}
#[test]
fn standard_row_locks_still_render_for_mysql() {
for (lock, expected) in [
(crate::RowLock::ForUpdate, "FOR UPDATE"),
(crate::RowLock::ForShare, "FOR SHARE"),
(
crate::RowLock::ForUpdateSkipLocked,
"FOR UPDATE SKIP LOCKED",
),
(crate::RowLock::ForShareSkipLocked, "FOR SHARE SKIP LOCKED"),
] {
let builder = QueryBuilder::new(make_sync_test_pool(), "accounts", false)
.field(crate::field!("id"));
let (sql, _) = builder
.render_for_transaction(Some(lock))
.expect("MySQL 标准行锁应可渲染");
assert!(sql.ends_with(expected), "{lock:?} 渲染结果异常: {sql}");
}
}
}