use crate::error::DbError;
use crate::isolation::IsolationLevel;
use crate::postgres::params::{json_signature, keyed_sql, PgUntypedNull};
use crate::postgres::query_builder::QueryBuilder;
use sqlx::Transaction as SqlxTransaction;
use std::collections::VecDeque;
use std::sync::atomic::{AtomicU64, Ordering};
pub(crate) const DEFAULT_STREAM_BATCH_SIZE: usize = 1000;
const XACT_LOCK_SQL: &str = "SELECT pg_advisory_xact_lock($1)";
const XACT_LOCK_SHARED_SQL: &str = "SELECT pg_advisory_xact_lock_shared($1)";
const XACT_TRY_LOCK_SQL: &str = "SELECT pg_try_advisory_xact_lock($1)";
const XACT_TRY_LOCK_SHARED_SQL: &str = "SELECT pg_try_advisory_xact_lock_shared($1)";
static STREAM_CURSOR_COUNTER: AtomicU64 = AtomicU64::new(1);
pub(crate) fn next_cursor_name() -> String {
format!(
"yang_cursor_{}",
STREAM_CURSOR_COUNTER.fetch_add(1, Ordering::Relaxed)
)
}
pub(crate) fn normalize_stream_sql(sql: &str) -> Result<&str, DbError> {
let trimmed = sql.trim().trim_end_matches(';').trim_end();
if trimmed.is_empty() {
return Err(DbError::InvalidArgument(
"流式查询的 SQL 不能为空".to_string(),
));
}
Ok(trimmed)
}
fn savepoint_statement(prefix: &str, name: &str) -> Result<String, DbError> {
Ok(format!(
"{prefix} {}",
crate::postgres::identifier::quote_identifier(name)?
))
}
const MAX_PREPARED_GID_BYTES: usize = 200;
pub(crate) fn validate_prepared_gid(gid: &str) -> Result<(), DbError> {
if gid.is_empty() || gid.len() > MAX_PREPARED_GID_BYTES {
return Err(DbError::InvalidArgument(format!(
"两阶段提交 GID 长度必须在 1..={MAX_PREPARED_GID_BYTES} 字节,当前 {} 字节",
gid.len()
)));
}
if !gid
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | '-' | ':'))
{
return Err(DbError::InvalidArgument(format!(
"两阶段提交 GID 只允许 ASCII 字母、数字与 _ . - : 字符: {gid:?}"
)));
}
Ok(())
}
fn quote_guc_name(key: &str) -> Result<String, DbError> {
if key.is_empty() || key.len() > 128 {
return Err(DbError::InvalidArgument(format!(
"会话 GUC 名长度必须在 1..=128 字节: {key:?}"
)));
}
let parts = key
.split('.')
.map(crate::sql_types::Identifier::parse)
.collect::<Result<Vec<_>, _>>()?;
if parts.is_empty() || parts.len() > 3 {
return Err(DbError::InvalidArgument(format!(
"会话 GUC 名最多三段(`prefix.name`): {key:?}"
)));
}
Ok(format!("'{key}'"))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum TableLockMode {
AccessShare,
RowShare,
RowExclusive,
ShareUpdateExclusive,
Share,
ShareRowExclusive,
Exclusive,
AccessExclusive,
}
impl TableLockMode {
pub fn as_sql(self) -> &'static str {
match self {
Self::AccessShare => "ACCESS SHARE",
Self::RowShare => "ROW SHARE",
Self::RowExclusive => "ROW EXCLUSIVE",
Self::ShareUpdateExclusive => "SHARE UPDATE EXCLUSIVE",
Self::Share => "SHARE",
Self::ShareRowExclusive => "SHARE ROW EXCLUSIVE",
Self::Exclusive => "EXCLUSIVE",
Self::AccessExclusive => "ACCESS EXCLUSIVE",
}
}
}
fn lock_table_statement(table: &str, mode: TableLockMode) -> Result<String, DbError> {
let quoted = crate::postgres::identifier::quote_table(table)?;
Ok(format!("LOCK TABLE {quoted} IN {} MODE", mode.as_sql()))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[non_exhaustive]
pub struct TransactionOptions {
pub isolation: Option<IsolationLevel>,
pub read_only: bool,
pub deferrable: bool,
}
impl TransactionOptions {
pub fn new() -> Self {
Self::default()
}
pub fn read_only() -> Self {
Self {
read_only: true,
..Self::default()
}
}
pub fn with_isolation(mut self, isolation: IsolationLevel) -> Self {
self.isolation = Some(isolation);
self
}
pub fn with_read_only(mut self, read_only: bool) -> Self {
self.read_only = read_only;
self
}
pub fn with_deferrable(mut self, deferrable: bool) -> Self {
self.deferrable = deferrable;
self
}
pub(crate) fn set_transaction_sql(&self) -> Option<String> {
let mut modes = Vec::new();
if let Some(isolation) = self.isolation {
modes.push(format!("ISOLATION LEVEL {}", isolation.as_sql()));
}
if self.read_only {
modes.push("READ ONLY".to_string());
}
if self.deferrable {
modes.push("DEFERRABLE".to_string());
}
if modes.is_empty() {
None
} else {
Some(format!("SET TRANSACTION {}", modes.join(", ")))
}
}
}
pub struct Transaction {
tx: Option<SqlxTransaction<'static, sqlx::Postgres>>,
enable_logging: bool,
}
impl Transaction {
pub(crate) fn new(tx: SqlxTransaction<'static, sqlx::Postgres>, enable_logging: bool) -> Self {
Self {
tx: Some(tx),
enable_logging,
}
}
pub async fn commit(mut self) -> Result<(), DbError> {
if self.enable_logging {
log::debug!("提交事务");
}
if let Some(tx) = self.tx.take() {
tx.commit().await?;
}
Ok(())
}
pub async fn rollback(mut self) -> Result<(), DbError> {
if self.enable_logging {
log::debug!("回滚事务");
}
if let Some(tx) = self.tx.take() {
tx.rollback().await?;
}
Ok(())
}
#[deprecated(
since = "0.1.0",
note = "使用 execute_with_params / query_with_params 等参数化方法替代"
)]
pub async fn execute(&mut self, sql: &str) -> Result<u64, DbError> {
if self.enable_logging {
log::debug!("事务中执行: {}", sql);
}
if let Some(tx) = &mut self.tx {
let result = sqlx::query(sql).execute(&mut **tx).await?;
Ok(result.rows_affected())
} else {
Err(DbError::TransactionError("事务已提交或回滚".to_string()))
}
}
pub async fn execute_with_params(
&mut self,
sql: &str,
params: Vec<serde_json::Value>,
) -> Result<u64, DbError> {
if self.enable_logging {
log::debug!("事务中执行参数化语句: {}, 参数数量: {}", sql, params.len());
}
if let Some(tx) = &mut self.tx {
let statement = keyed_sql(sql, json_signature(¶ms));
let mut query = sqlx::query(&statement);
for param in ¶ms {
query = bind_json_param_tx(query, param);
}
let result = query.execute(&mut **tx).await?;
Ok(result.rows_affected())
} else {
Err(DbError::TransactionError("事务已提交或回滚".to_string()))
}
}
pub async fn query_with_params<T>(
&mut self,
sql: &str,
params: Vec<serde_json::Value>,
) -> Result<Vec<T>, DbError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
{
if self.enable_logging {
log::debug!("事务中执行参数化查询: {}, 参数数量: {}", sql, params.len());
}
if let Some(tx) = &mut self.tx {
let statement = keyed_sql(sql, json_signature(¶ms));
let mut query = sqlx::query_as::<_, T>(&statement);
for param in ¶ms {
query = bind_json_param_as_tx(query, param);
}
let rows = query.fetch_all(&mut **tx).await?;
Ok(rows)
} else {
Err(DbError::TransactionError("事务已提交或回滚".to_string()))
}
}
pub async fn select<T>(&mut self, query: QueryBuilder<'_>) -> Result<Vec<T>, DbError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
{
self.select_with_optional_lock(query, None).await
}
pub async fn select_for_update<T>(&mut self, query: QueryBuilder<'_>) -> Result<Vec<T>, DbError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
{
self.select_locked(query, crate::RowLock::ForUpdate).await
}
pub async fn select_for_share<T>(&mut self, query: QueryBuilder<'_>) -> Result<Vec<T>, DbError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
{
self.select_locked(query, crate::RowLock::ForShare).await
}
pub async fn select_locked<T>(
&mut self,
query: QueryBuilder<'_>,
lock: crate::RowLock,
) -> Result<Vec<T>, DbError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
{
self.select_with_optional_lock(query, Some(lock)).await
}
pub async fn select_locked_with<T>(
&mut self,
query: QueryBuilder<'_>,
lock: crate::RowLock,
of: &[&crate::FieldRef],
nowait: bool,
skip_locked: bool,
) -> Result<Vec<T>, DbError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
{
let (sql, params) = query.render_with_lock(lock, of, nowait, skip_locked)?;
self.fetch_all_with_sql(&sql, ¶ms).await
}
async fn select_with_optional_lock<T>(
&mut self,
query: QueryBuilder<'_>,
lock: Option<crate::RowLock>,
) -> Result<Vec<T>, DbError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
{
let (sql, params) = query.render_for_transaction(lock)?;
self.fetch_all_with_sql(&sql, ¶ms).await
}
async fn fetch_all_with_sql<T>(
&mut self,
sql: &str,
params: &[crate::postgres::SqlValue],
) -> Result<Vec<T>, DbError>
where
T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
{
if self.enable_logging {
log::debug!("事务中执行 SELECT: {}, 参数: {:?}", sql, params);
}
let tx = self
.tx
.as_mut()
.ok_or_else(|| DbError::TransactionError("事务已提交或回滚".to_string()))?;
let mut sql_query = sqlx::query_as::<_, T>(sql);
for param in params {
sql_query = crate::postgres::query_builder::bind_param(sql_query, param);
}
Ok(sql_query.fetch_all(&mut **tx).await?)
}
pub fn table(&mut self, table: &crate::TableRef) -> QueryBuilder<'_> {
let enable_logging = self.enable_logging;
QueryBuilder::new_transaction(self, table.as_str(), enable_logging)
}
#[doc(hidden)]
pub fn executor(&mut self) -> Option<&mut sqlx::PgConnection> {
self.tx.as_deref_mut()
}
pub async fn savepoint(&mut self, name: &str) -> Result<(), DbError> {
let sql = savepoint_statement("SAVEPOINT", name)?;
self.execute_control(&sql).await
}
pub async fn rollback_to(&mut self, name: &str) -> Result<(), DbError> {
let sql = savepoint_statement("ROLLBACK TO SAVEPOINT", name)?;
self.execute_control(&sql).await
}
pub async fn release_savepoint(&mut self, name: &str) -> Result<(), DbError> {
let sql = savepoint_statement("RELEASE SAVEPOINT", name)?;
self.execute_control(&sql).await
}
pub async fn set_local(&mut self, key: &str, value: &str) -> Result<(), DbError> {
let quoted = quote_guc_name(key)?;
let sql = format!("SELECT set_config({quoted}, $1, true)");
if self.enable_logging {
log::debug!("设置事务级会话参数: {}", key);
}
let tx = self.active_tx()?;
sqlx::query(&sql).bind(value).execute(&mut **tx).await?;
Ok(())
}
pub async fn lock_table(
&mut self,
table: &crate::TableRef,
mode: TableLockMode,
) -> Result<(), DbError> {
let sql = lock_table_statement(table.as_str(), mode)?;
self.execute_control(&sql).await
}
pub async fn prepare(mut self, gid: &str) -> Result<(), DbError> {
validate_prepared_gid(gid)?;
let mut tx = self
.tx
.take()
.ok_or_else(|| DbError::TransactionError("事务已提交或回滚".to_string()))?;
let sql = format!("PREPARE TRANSACTION '{gid}'");
if self.enable_logging {
log::debug!("准备两阶段提交: gid={gid}");
}
let result = sqlx::query(&sql).execute(&mut *tx).await;
match result {
Ok(_) => {
let _ = tx.rollback().await;
Ok(())
}
Err(error) => {
let error = DbError::from(error);
let _ = tx.rollback().await;
if error.sqlstate() == Some("55000") {
return Err(DbError::TransactionError(
"两阶段提交不可用:服务端 max_prepared_transactions 为 0;请启用后重试"
.to_string(),
));
}
Err(error)
}
}
}
pub async fn advisory_xact_lock(&mut self, key: i64) -> Result<(), DbError> {
let tx = self.active_tx()?;
sqlx::query(XACT_LOCK_SQL)
.bind(key)
.execute(&mut **tx)
.await?;
Ok(())
}
pub async fn advisory_xact_lock_shared(&mut self, key: i64) -> Result<(), DbError> {
let tx = self.active_tx()?;
sqlx::query(XACT_LOCK_SHARED_SQL)
.bind(key)
.execute(&mut **tx)
.await?;
Ok(())
}
pub async fn try_advisory_xact_lock(&mut self, key: i64) -> Result<bool, DbError> {
let tx = self.active_tx()?;
let acquired: bool = sqlx::query_scalar(XACT_TRY_LOCK_SQL)
.bind(key)
.fetch_one(&mut **tx)
.await?;
Ok(acquired)
}
pub async fn try_advisory_xact_lock_shared(&mut self, key: i64) -> Result<bool, DbError> {
let tx = self.active_tx()?;
let acquired: bool = sqlx::query_scalar(XACT_TRY_LOCK_SHARED_SQL)
.bind(key)
.fetch_one(&mut **tx)
.await?;
Ok(acquired)
}
pub async fn execute_script_in_transaction(&mut self, script: &str) -> Result<usize, DbError> {
let statements = crate::postgres::init::split_sql_script(script)?;
crate::postgres::init::execute_statements(self, &statements).await?;
Ok(statements.len())
}
pub async fn stream_query(
&mut self,
sql: &str,
params: Vec<serde_json::Value>,
) -> Result<TxRowCursor<'_>, DbError> {
self.stream_query_with_batch_size(sql, params, DEFAULT_STREAM_BATCH_SIZE)
.await
}
pub async fn stream_query_with_batch_size(
&mut self,
sql: &str,
params: Vec<serde_json::Value>,
batch_size: usize,
) -> Result<TxRowCursor<'_>, DbError> {
if batch_size == 0 {
return Err(DbError::InvalidArgument(
"流式查询 batch_size 必须大于 0".to_string(),
));
}
let body = normalize_stream_sql(sql)?;
let cursor_name = next_cursor_name();
let declare = format!(
"DECLARE {} CURSOR FOR {}",
crate::postgres::identifier::quote_identifier(&cursor_name)?,
body
);
let enable_logging = self.enable_logging;
{
let tx = self.active_tx()?;
if enable_logging {
log::debug!("事务内声明游标: {}", declare);
}
let keyed_declare = keyed_sql(&declare, json_signature(¶ms));
let mut query = sqlx::query(&keyed_declare);
for param in ¶ms {
query = bind_json_param_tx(query, param);
}
query.execute(&mut **tx).await?;
}
let tx = self.active_tx()?;
Ok(TxRowCursor::new(
tx,
cursor_name,
batch_size,
enable_logging,
))
}
async fn execute_control(&mut self, sql: &str) -> Result<(), DbError> {
if self.enable_logging {
log::debug!("事务控制语句: {}", sql);
}
let tx = self.active_tx()?;
sqlx::query(sql).execute(&mut **tx).await?;
Ok(())
}
fn active_tx(&mut self) -> Result<&mut SqlxTransaction<'static, sqlx::Postgres>, DbError> {
self.tx
.as_mut()
.ok_or_else(|| DbError::TransactionError("事务已提交或回滚".to_string()))
}
}
impl Drop for Transaction {
fn drop(&mut self) {
if self.tx.is_some() {
log::warn!(
"PG 事务被丢弃而未提交/回滚——底层将自动回滚。请显式调用 commit() 或 rollback()。"
);
}
}
}
pub struct TxRowCursor<'a> {
conn: &'a mut sqlx::PgConnection,
cursor_name: String,
batch_size: usize,
buffer: VecDeque<sqlx::postgres::PgRow>,
exhausted: bool,
closed: bool,
enable_logging: bool,
}
impl<'a> TxRowCursor<'a> {
fn new(
conn: &'a mut sqlx::PgConnection,
cursor_name: String,
batch_size: usize,
enable_logging: bool,
) -> Self {
Self {
conn,
cursor_name,
batch_size,
buffer: VecDeque::with_capacity(batch_size.min(1024)),
exhausted: false,
closed: false,
enable_logging,
}
}
pub fn batch_size(&self) -> usize {
self.batch_size
}
pub async fn next(&mut self) -> Result<Option<sqlx::postgres::PgRow>, DbError> {
loop {
if let Some(row) = self.buffer.pop_front() {
return Ok(Some(row));
}
if self.exhausted {
self.close_inner().await?;
return Ok(None);
}
self.fetch_batch().await?;
}
}
pub async fn close(mut self) -> Result<(), DbError> {
self.buffer.clear();
self.close_inner().await
}
async fn fetch_batch(&mut self) -> Result<(), DbError> {
let sql = format!(
"FETCH FORWARD {} FROM {}",
self.batch_size,
crate::postgres::identifier::quote_identifier(&self.cursor_name)?
);
if self.enable_logging {
log::debug!("事务内游标拉取: {}", sql);
}
let rows = sqlx::query(&sql).fetch_all(&mut *self.conn).await?;
if rows.len() < self.batch_size {
self.exhausted = true;
}
self.buffer.extend(rows);
Ok(())
}
async fn close_inner(&mut self) -> Result<(), DbError> {
if self.closed {
return Ok(());
}
self.closed = true;
self.exhausted = true;
let sql = format!(
"CLOSE {}",
crate::postgres::identifier::quote_identifier(&self.cursor_name)?
);
sqlx::query(&sql).execute(&mut *self.conn).await?;
Ok(())
}
}
fn bind_json_param_tx<'q>(
query: sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments>,
param: &serde_json::Value,
) -> sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments> {
match param {
serde_json::Value::String(value) => query.bind(value.clone()),
serde_json::Value::Number(value) => match crate::json_param::classify_json_number(value) {
Some(crate::json_param::JsonNumber::Int(i)) => query.bind(i),
Some(crate::json_param::JsonNumber::Uint(u)) => query.bind(u.to_string()),
Some(crate::json_param::JsonNumber::Float(f)) => query.bind(f),
None => query.bind(PgUntypedNull),
},
serde_json::Value::Bool(value) => query.bind(*value),
serde_json::Value::Null => query.bind(PgUntypedNull),
other => query.bind(other.clone()),
}
}
fn bind_json_param_as_tx<'q, T>(
query: sqlx::query::QueryAs<'q, sqlx::Postgres, T, sqlx::postgres::PgArguments>,
param: &serde_json::Value,
) -> sqlx::query::QueryAs<'q, sqlx::Postgres, T, sqlx::postgres::PgArguments>
where
T: for<'row> sqlx::FromRow<'row, sqlx::postgres::PgRow>,
{
match param {
serde_json::Value::String(value) => query.bind(value.clone()),
serde_json::Value::Number(value) => match crate::json_param::classify_json_number(value) {
Some(crate::json_param::JsonNumber::Int(i)) => query.bind(i),
Some(crate::json_param::JsonNumber::Uint(u)) => query.bind(u.to_string()),
Some(crate::json_param::JsonNumber::Float(f)) => query.bind(f),
None => query.bind(PgUntypedNull),
},
serde_json::Value::Bool(value) => query.bind(*value),
serde_json::Value::Null => query.bind(PgUntypedNull),
other => query.bind(other.clone()),
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
#[test]
fn transaction_options_default_emits_no_set_transaction() {
assert_eq!(TransactionOptions::default().set_transaction_sql(), None);
assert_eq!(TransactionOptions::new().set_transaction_sql(), None);
}
#[test]
fn transaction_options_renders_isolation_read_only_and_deferrable() {
let isolation_only =
TransactionOptions::default().with_isolation(IsolationLevel::Serializable);
assert_eq!(
isolation_only.set_transaction_sql().as_deref(),
Some("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE")
);
assert_eq!(
TransactionOptions::read_only()
.set_transaction_sql()
.as_deref(),
Some("SET TRANSACTION READ ONLY")
);
let full = TransactionOptions::default()
.with_isolation(IsolationLevel::RepeatableRead)
.with_read_only(true)
.with_deferrable(true);
assert_eq!(
full.set_transaction_sql().as_deref(),
Some("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ ONLY, DEFERRABLE")
);
}
#[test]
fn savepoint_statements_quote_names_and_reject_injection() {
assert_eq!(
savepoint_statement("SAVEPOINT", "sp_1").unwrap(),
"SAVEPOINT \"sp_1\""
);
assert_eq!(
savepoint_statement("ROLLBACK TO SAVEPOINT", "sp_1").unwrap(),
"ROLLBACK TO SAVEPOINT \"sp_1\""
);
assert_eq!(
savepoint_statement("RELEASE SAVEPOINT", "sp_1").unwrap(),
"RELEASE SAVEPOINT \"sp_1\""
);
for invalid in ["", "1sp", "sp; DROP TABLE t"] {
assert!(
matches!(
savepoint_statement("SAVEPOINT", invalid),
Err(DbError::InvalidArgument(_))
),
"保存点名应拒绝 {invalid:?}"
);
}
assert_eq!(
savepoint_statement("SAVEPOINT", "sp\"x").unwrap(),
"SAVEPOINT \"sp\"\"x\""
);
}
#[test]
fn advisory_xact_lock_sql_covers_shared_and_exclusive() {
assert_eq!(XACT_LOCK_SQL, "SELECT pg_advisory_xact_lock($1)");
assert_eq!(
XACT_LOCK_SHARED_SQL,
"SELECT pg_advisory_xact_lock_shared($1)"
);
assert_eq!(XACT_TRY_LOCK_SQL, "SELECT pg_try_advisory_xact_lock($1)");
assert_eq!(
XACT_TRY_LOCK_SHARED_SQL,
"SELECT pg_try_advisory_xact_lock_shared($1)"
);
}
#[test]
fn stream_sql_is_normalized_and_empty_is_rejected() {
assert_eq!(normalize_stream_sql(" SELECT 1; ").unwrap(), "SELECT 1");
assert_eq!(normalize_stream_sql("SELECT 1;;").unwrap(), "SELECT 1");
assert!(matches!(
normalize_stream_sql(" ; "),
Err(DbError::InvalidArgument(_))
));
}
#[test]
fn cursor_names_are_unique_and_identifier_safe() {
let first = next_cursor_name();
let second = next_cursor_name();
assert_ne!(first, second);
assert!(crate::postgres::identifier::is_valid_identifier(&first));
assert!(crate::postgres::identifier::is_valid_identifier(&second));
}
#[test]
fn guc_names_allow_dotted_identifiers_and_reject_injection() {
assert_eq!(quote_guc_name("app.tenant_id").unwrap(), "'app.tenant_id'");
assert_eq!(
quote_guc_name("statement_timeout").unwrap(),
"'statement_timeout'"
);
for invalid in [
"",
".app",
"app.",
"app..tenant",
"a.b.c.d",
"app.tenant_id = 'x'",
"app.tenant_id; DROP TABLE t",
"app tenant",
"app\"tenant\"",
] {
assert!(
matches!(quote_guc_name(invalid), Err(DbError::InvalidArgument(_))),
"GUC 名应拒绝 {invalid:?}"
);
}
}
#[test]
fn prepared_gid_validation_is_strict_whitelist() {
assert!(validate_prepared_gid("phase_c_gid-1.2:3").is_ok());
assert!(validate_prepared_gid(&"a".repeat(MAX_PREPARED_GID_BYTES)).is_ok());
for invalid in [
"",
"gid with space",
"gid'; DROP TABLE t; --",
"gid\"x",
"gid\nx",
] {
assert!(
matches!(
validate_prepared_gid(invalid),
Err(DbError::InvalidArgument(_))
),
"GID 应拒绝 {invalid:?}"
);
}
assert!(matches!(
validate_prepared_gid(&"a".repeat(MAX_PREPARED_GID_BYTES + 1)),
Err(DbError::InvalidArgument(_))
));
}
#[test]
fn lock_table_statement_quotes_table_and_uses_controlled_mode() {
assert_eq!(
lock_table_statement("phase_c.locks", TableLockMode::AccessExclusive).unwrap(),
"LOCK TABLE \"phase_c\".\"locks\" IN ACCESS EXCLUSIVE MODE"
);
assert_eq!(
lock_table_statement("locks", TableLockMode::ShareRowExclusive).unwrap(),
"LOCK TABLE \"locks\" IN SHARE ROW EXCLUSIVE MODE"
);
assert!(matches!(
lock_table_statement("locks; DROP TABLE t", TableLockMode::Share),
Err(DbError::InvalidArgument(_))
));
let modes = [
(TableLockMode::AccessShare, "ACCESS SHARE"),
(TableLockMode::RowShare, "ROW SHARE"),
(TableLockMode::RowExclusive, "ROW EXCLUSIVE"),
(
TableLockMode::ShareUpdateExclusive,
"SHARE UPDATE EXCLUSIVE",
),
(TableLockMode::Share, "SHARE"),
(TableLockMode::ShareRowExclusive, "SHARE ROW EXCLUSIVE"),
(TableLockMode::Exclusive, "EXCLUSIVE"),
(TableLockMode::AccessExclusive, "ACCESS EXCLUSIVE"),
];
for (mode, expected) in modes {
assert_eq!(mode.as_sql(), expected);
}
}
}