1use crate::error::DbError;
2use crate::isolation::IsolationLevel;
3use crate::postgres::params::{json_signature, keyed_sql, PgUntypedNull};
4use crate::postgres::query_builder::QueryBuilder;
5use sqlx::Transaction as SqlxTransaction;
6use std::collections::VecDeque;
7use std::sync::atomic::{AtomicU64, Ordering};
8
9pub(crate) const DEFAULT_STREAM_BATCH_SIZE: usize = 1000;
11
12const XACT_LOCK_SQL: &str = "SELECT pg_advisory_xact_lock($1)";
14const XACT_LOCK_SHARED_SQL: &str = "SELECT pg_advisory_xact_lock_shared($1)";
16const XACT_TRY_LOCK_SQL: &str = "SELECT pg_try_advisory_xact_lock($1)";
18const XACT_TRY_LOCK_SHARED_SQL: &str = "SELECT pg_try_advisory_xact_lock_shared($1)";
20
21static STREAM_CURSOR_COUNTER: AtomicU64 = AtomicU64::new(1);
23
24pub(crate) fn next_cursor_name() -> String {
26 format!(
27 "yang_cursor_{}",
28 STREAM_CURSOR_COUNTER.fetch_add(1, Ordering::Relaxed)
29 )
30}
31
32pub(crate) fn normalize_stream_sql(sql: &str) -> Result<&str, DbError> {
34 let trimmed = sql.trim().trim_end_matches(';').trim_end();
35 if trimmed.is_empty() {
36 return Err(DbError::InvalidArgument(
37 "流式查询的 SQL 不能为空".to_string(),
38 ));
39 }
40 Ok(trimmed)
41}
42
43fn savepoint_statement(prefix: &str, name: &str) -> Result<String, DbError> {
45 Ok(format!(
46 "{prefix} {}",
47 crate::postgres::identifier::quote_identifier(name)?
48 ))
49}
50
51const MAX_PREPARED_GID_BYTES: usize = 200;
53
54pub(crate) fn validate_prepared_gid(gid: &str) -> Result<(), DbError> {
60 if gid.is_empty() || gid.len() > MAX_PREPARED_GID_BYTES {
61 return Err(DbError::InvalidArgument(format!(
62 "两阶段提交 GID 长度必须在 1..={MAX_PREPARED_GID_BYTES} 字节,当前 {} 字节",
63 gid.len()
64 )));
65 }
66 if !gid
67 .chars()
68 .all(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | '-' | ':'))
69 {
70 return Err(DbError::InvalidArgument(format!(
71 "两阶段提交 GID 只允许 ASCII 字母、数字与 _ . - : 字符: {gid:?}"
72 )));
73 }
74 Ok(())
75}
76
77fn quote_guc_name(key: &str) -> Result<String, DbError> {
83 if key.is_empty() || key.len() > 128 {
84 return Err(DbError::InvalidArgument(format!(
85 "会话 GUC 名长度必须在 1..=128 字节: {key:?}"
86 )));
87 }
88 let parts = key
89 .split('.')
90 .map(crate::sql_types::Identifier::parse)
91 .collect::<Result<Vec<_>, _>>()?;
92 if parts.is_empty() || parts.len() > 3 {
93 return Err(DbError::InvalidArgument(format!(
94 "会话 GUC 名最多三段(`prefix.name`): {key:?}"
95 )));
96 }
97 Ok(format!("'{key}'"))
100}
101
102#[derive(Debug, Clone, Copy, PartialEq, Eq)]
106#[non_exhaustive]
107pub enum TableLockMode {
108 AccessShare,
110 RowShare,
112 RowExclusive,
114 ShareUpdateExclusive,
116 Share,
118 ShareRowExclusive,
120 Exclusive,
122 AccessExclusive,
124}
125
126impl TableLockMode {
127 pub fn as_sql(self) -> &'static str {
129 match self {
130 Self::AccessShare => "ACCESS SHARE",
131 Self::RowShare => "ROW SHARE",
132 Self::RowExclusive => "ROW EXCLUSIVE",
133 Self::ShareUpdateExclusive => "SHARE UPDATE EXCLUSIVE",
134 Self::Share => "SHARE",
135 Self::ShareRowExclusive => "SHARE ROW EXCLUSIVE",
136 Self::Exclusive => "EXCLUSIVE",
137 Self::AccessExclusive => "ACCESS EXCLUSIVE",
138 }
139 }
140}
141
142fn lock_table_statement(table: &str, mode: TableLockMode) -> Result<String, DbError> {
144 let quoted = crate::postgres::identifier::quote_table(table)?;
145 Ok(format!("LOCK TABLE {quoted} IN {} MODE", mode.as_sql()))
146}
147
148#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
156#[non_exhaustive]
157pub struct TransactionOptions {
158 pub isolation: Option<IsolationLevel>,
160 pub read_only: bool,
162 pub deferrable: bool,
164}
165
166impl TransactionOptions {
167 pub fn new() -> Self {
169 Self::default()
170 }
171
172 pub fn read_only() -> Self {
174 Self {
175 read_only: true,
176 ..Self::default()
177 }
178 }
179
180 pub fn with_isolation(mut self, isolation: IsolationLevel) -> Self {
182 self.isolation = Some(isolation);
183 self
184 }
185
186 pub fn with_read_only(mut self, read_only: bool) -> Self {
188 self.read_only = read_only;
189 self
190 }
191
192 pub fn with_deferrable(mut self, deferrable: bool) -> Self {
194 self.deferrable = deferrable;
195 self
196 }
197
198 pub(crate) fn set_transaction_sql(&self) -> Option<String> {
200 let mut modes = Vec::new();
201 if let Some(isolation) = self.isolation {
202 modes.push(format!("ISOLATION LEVEL {}", isolation.as_sql()));
203 }
204 if self.read_only {
205 modes.push("READ ONLY".to_string());
206 }
207 if self.deferrable {
208 modes.push("DEFERRABLE".to_string());
209 }
210 if modes.is_empty() {
211 None
212 } else {
213 Some(format!("SET TRANSACTION {}", modes.join(", ")))
214 }
215 }
216}
217
218pub struct Transaction {
220 tx: Option<SqlxTransaction<'static, sqlx::Postgres>>,
221 enable_logging: bool,
222}
223
224impl Transaction {
225 pub(crate) fn new(tx: SqlxTransaction<'static, sqlx::Postgres>, enable_logging: bool) -> Self {
227 Self {
228 tx: Some(tx),
229 enable_logging,
230 }
231 }
232
233 pub async fn commit(mut self) -> Result<(), DbError> {
235 if self.enable_logging {
236 log::debug!("提交事务");
237 }
238
239 if let Some(tx) = self.tx.take() {
240 tx.commit().await?;
241 }
242
243 Ok(())
244 }
245
246 pub async fn rollback(mut self) -> Result<(), DbError> {
248 if self.enable_logging {
249 log::debug!("回滚事务");
250 }
251
252 if let Some(tx) = self.tx.take() {
253 tx.rollback().await?;
254 }
255
256 Ok(())
257 }
258
259 #[deprecated(
267 since = "0.1.0",
268 note = "使用 execute_with_params / query_with_params 等参数化方法替代"
269 )]
270 pub async fn execute(&mut self, sql: &str) -> Result<u64, DbError> {
271 if self.enable_logging {
272 log::debug!("事务中执行: {}", sql);
273 }
274
275 if let Some(tx) = &mut self.tx {
276 let result = sqlx::query(sql).execute(&mut **tx).await?;
277 Ok(result.rows_affected())
278 } else {
279 Err(DbError::TransactionError("事务已提交或回滚".to_string()))
280 }
281 }
282
283 pub async fn execute_with_params(
309 &mut self,
310 sql: &str,
311 params: Vec<serde_json::Value>,
312 ) -> Result<u64, DbError> {
313 if self.enable_logging {
314 log::debug!("事务中执行参数化语句: {}, 参数数量: {}", sql, params.len());
315 }
316
317 if let Some(tx) = &mut self.tx {
318 let statement = keyed_sql(sql, json_signature(¶ms));
320 let mut query = sqlx::query(&statement);
321 for param in ¶ms {
322 query = bind_json_param_tx(query, param);
323 }
324 let result = query.execute(&mut **tx).await?;
325 Ok(result.rows_affected())
326 } else {
327 Err(DbError::TransactionError("事务已提交或回滚".to_string()))
328 }
329 }
330
331 pub async fn query_with_params<T>(
357 &mut self,
358 sql: &str,
359 params: Vec<serde_json::Value>,
360 ) -> Result<Vec<T>, DbError>
361 where
362 T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
363 {
364 if self.enable_logging {
365 log::debug!("事务中执行参数化查询: {}, 参数数量: {}", sql, params.len());
366 }
367
368 if let Some(tx) = &mut self.tx {
369 let statement = keyed_sql(sql, json_signature(¶ms));
371 let mut query = sqlx::query_as::<_, T>(&statement);
372 for param in ¶ms {
373 query = bind_json_param_as_tx(query, param);
374 }
375 let rows = query.fetch_all(&mut **tx).await?;
376 Ok(rows)
377 } else {
378 Err(DbError::TransactionError("事务已提交或回滚".to_string()))
379 }
380 }
381
382 pub async fn select<T>(&mut self, query: QueryBuilder<'_>) -> Result<Vec<T>, DbError>
384 where
385 T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
386 {
387 self.select_with_optional_lock(query, None).await
388 }
389
390 pub async fn select_for_update<T>(&mut self, query: QueryBuilder<'_>) -> Result<Vec<T>, DbError>
392 where
393 T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
394 {
395 self.select_locked(query, crate::RowLock::ForUpdate).await
396 }
397
398 pub async fn select_for_share<T>(&mut self, query: QueryBuilder<'_>) -> Result<Vec<T>, DbError>
400 where
401 T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
402 {
403 self.select_locked(query, crate::RowLock::ForShare).await
404 }
405
406 pub async fn select_locked<T>(
408 &mut self,
409 query: QueryBuilder<'_>,
410 lock: crate::RowLock,
411 ) -> Result<Vec<T>, DbError>
412 where
413 T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
414 {
415 self.select_with_optional_lock(query, Some(lock)).await
416 }
417
418 pub async fn select_locked_with<T>(
426 &mut self,
427 query: QueryBuilder<'_>,
428 lock: crate::RowLock,
429 of: &[&crate::FieldRef],
430 nowait: bool,
431 skip_locked: bool,
432 ) -> Result<Vec<T>, DbError>
433 where
434 T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
435 {
436 let (sql, params) = query.render_with_lock(lock, of, nowait, skip_locked)?;
437 self.fetch_all_with_sql(&sql, ¶ms).await
438 }
439
440 async fn select_with_optional_lock<T>(
441 &mut self,
442 query: QueryBuilder<'_>,
443 lock: Option<crate::RowLock>,
444 ) -> Result<Vec<T>, DbError>
445 where
446 T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
447 {
448 let (sql, params) = query.render_for_transaction(lock)?;
449 self.fetch_all_with_sql(&sql, ¶ms).await
450 }
451
452 async fn fetch_all_with_sql<T>(
454 &mut self,
455 sql: &str,
456 params: &[crate::postgres::SqlValue],
457 ) -> Result<Vec<T>, DbError>
458 where
459 T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
460 {
461 if self.enable_logging {
462 log::debug!("事务中执行 SELECT: {}, 参数: {:?}", sql, params);
463 }
464 let tx = self
465 .tx
466 .as_mut()
467 .ok_or_else(|| DbError::TransactionError("事务已提交或回滚".to_string()))?;
468 let mut sql_query = sqlx::query_as::<_, T>(sql);
469 for param in params {
470 sql_query = crate::postgres::query_builder::bind_param(sql_query, param);
471 }
472 Ok(sql_query.fetch_all(&mut **tx).await?)
473 }
474
475 pub fn table(&mut self, table: &crate::TableRef) -> QueryBuilder<'_> {
509 let enable_logging = self.enable_logging;
510 QueryBuilder::new_transaction(self, table.as_str(), enable_logging)
511 }
512
513 #[doc(hidden)]
523 pub fn executor(&mut self) -> Option<&mut sqlx::PgConnection> {
524 self.tx.as_deref_mut()
526 }
527
528 pub async fn savepoint(&mut self, name: &str) -> Result<(), DbError> {
533 let sql = savepoint_statement("SAVEPOINT", name)?;
534 self.execute_control(&sql).await
535 }
536
537 pub async fn rollback_to(&mut self, name: &str) -> Result<(), DbError> {
541 let sql = savepoint_statement("ROLLBACK TO SAVEPOINT", name)?;
542 self.execute_control(&sql).await
543 }
544
545 pub async fn release_savepoint(&mut self, name: &str) -> Result<(), DbError> {
547 let sql = savepoint_statement("RELEASE SAVEPOINT", name)?;
548 self.execute_control(&sql).await
549 }
550
551 pub async fn set_local(&mut self, key: &str, value: &str) -> Result<(), DbError> {
561 let quoted = quote_guc_name(key)?;
562 let sql = format!("SELECT set_config({quoted}, $1, true)");
563 if self.enable_logging {
564 log::debug!("设置事务级会话参数: {}", key);
565 }
566 let tx = self.active_tx()?;
567 sqlx::query(&sql).bind(value).execute(&mut **tx).await?;
568 Ok(())
569 }
570
571 pub async fn lock_table(
576 &mut self,
577 table: &crate::TableRef,
578 mode: TableLockMode,
579 ) -> Result<(), DbError> {
580 let sql = lock_table_statement(table.as_str(), mode)?;
581 self.execute_control(&sql).await
582 }
583
584 pub async fn prepare(mut self, gid: &str) -> Result<(), DbError> {
594 validate_prepared_gid(gid)?;
595 let mut tx = self
596 .tx
597 .take()
598 .ok_or_else(|| DbError::TransactionError("事务已提交或回滚".to_string()))?;
599 let sql = format!("PREPARE TRANSACTION '{gid}'");
600 if self.enable_logging {
601 log::debug!("准备两阶段提交: gid={gid}");
602 }
603 let result = sqlx::query(&sql).execute(&mut *tx).await;
604 match result {
605 Ok(_) => {
606 let _ = tx.rollback().await;
609 Ok(())
610 }
611 Err(error) => {
612 let error = DbError::from(error);
613 let _ = tx.rollback().await;
614 if error.sqlstate() == Some("55000") {
615 return Err(DbError::TransactionError(
616 "两阶段提交不可用:服务端 max_prepared_transactions 为 0;请启用后重试"
617 .to_string(),
618 ));
619 }
620 Err(error)
621 }
622 }
623 }
624
625 pub async fn advisory_xact_lock(&mut self, key: i64) -> Result<(), DbError> {
630 let tx = self.active_tx()?;
631 sqlx::query(XACT_LOCK_SQL)
632 .bind(key)
633 .execute(&mut **tx)
634 .await?;
635 Ok(())
636 }
637
638 pub async fn advisory_xact_lock_shared(&mut self, key: i64) -> Result<(), DbError> {
642 let tx = self.active_tx()?;
643 sqlx::query(XACT_LOCK_SHARED_SQL)
644 .bind(key)
645 .execute(&mut **tx)
646 .await?;
647 Ok(())
648 }
649
650 pub async fn try_advisory_xact_lock(&mut self, key: i64) -> Result<bool, DbError> {
654 let tx = self.active_tx()?;
655 let acquired: bool = sqlx::query_scalar(XACT_TRY_LOCK_SQL)
656 .bind(key)
657 .fetch_one(&mut **tx)
658 .await?;
659 Ok(acquired)
660 }
661
662 pub async fn try_advisory_xact_lock_shared(&mut self, key: i64) -> Result<bool, DbError> {
664 let tx = self.active_tx()?;
665 let acquired: bool = sqlx::query_scalar(XACT_TRY_LOCK_SHARED_SQL)
666 .bind(key)
667 .fetch_one(&mut **tx)
668 .await?;
669 Ok(acquired)
670 }
671
672 pub async fn execute_script_in_transaction(&mut self, script: &str) -> Result<usize, DbError> {
681 let statements = crate::postgres::init::split_sql_script(script)?;
682 crate::postgres::init::execute_statements(self, &statements).await?;
683 Ok(statements.len())
684 }
685
686 pub async fn stream_query(
696 &mut self,
697 sql: &str,
698 params: Vec<serde_json::Value>,
699 ) -> Result<TxRowCursor<'_>, DbError> {
700 self.stream_query_with_batch_size(sql, params, DEFAULT_STREAM_BATCH_SIZE)
701 .await
702 }
703
704 pub async fn stream_query_with_batch_size(
706 &mut self,
707 sql: &str,
708 params: Vec<serde_json::Value>,
709 batch_size: usize,
710 ) -> Result<TxRowCursor<'_>, DbError> {
711 if batch_size == 0 {
712 return Err(DbError::InvalidArgument(
713 "流式查询 batch_size 必须大于 0".to_string(),
714 ));
715 }
716 let body = normalize_stream_sql(sql)?;
717 let cursor_name = next_cursor_name();
718 let declare = format!(
719 "DECLARE {} CURSOR FOR {}",
720 crate::postgres::identifier::quote_identifier(&cursor_name)?,
721 body
722 );
723 let enable_logging = self.enable_logging;
724 {
725 let tx = self.active_tx()?;
726 if enable_logging {
727 log::debug!("事务内声明游标: {}", declare);
728 }
729 let keyed_declare = keyed_sql(&declare, json_signature(¶ms));
730 let mut query = sqlx::query(&keyed_declare);
731 for param in ¶ms {
732 query = bind_json_param_tx(query, param);
733 }
734 query.execute(&mut **tx).await?;
735 }
736 let tx = self.active_tx()?;
737 Ok(TxRowCursor::new(
738 tx,
739 cursor_name,
740 batch_size,
741 enable_logging,
742 ))
743 }
744
745 async fn execute_control(&mut self, sql: &str) -> Result<(), DbError> {
747 if self.enable_logging {
748 log::debug!("事务控制语句: {}", sql);
749 }
750 let tx = self.active_tx()?;
751 sqlx::query(sql).execute(&mut **tx).await?;
752 Ok(())
753 }
754
755 fn active_tx(&mut self) -> Result<&mut SqlxTransaction<'static, sqlx::Postgres>, DbError> {
757 self.tx
758 .as_mut()
759 .ok_or_else(|| DbError::TransactionError("事务已提交或回滚".to_string()))
760 }
761}
762
763impl Drop for Transaction {
765 fn drop(&mut self) {
766 if self.tx.is_some() {
767 log::warn!(
768 "PG 事务被丢弃而未提交/回滚——底层将自动回滚。请显式调用 commit() 或 rollback()。"
769 );
770 }
771 }
772}
773
774pub struct TxRowCursor<'a> {
779 conn: &'a mut sqlx::PgConnection,
780 cursor_name: String,
781 batch_size: usize,
782 buffer: VecDeque<sqlx::postgres::PgRow>,
783 exhausted: bool,
784 closed: bool,
785 enable_logging: bool,
786}
787
788impl<'a> TxRowCursor<'a> {
789 fn new(
790 conn: &'a mut sqlx::PgConnection,
791 cursor_name: String,
792 batch_size: usize,
793 enable_logging: bool,
794 ) -> Self {
795 Self {
796 conn,
797 cursor_name,
798 batch_size,
799 buffer: VecDeque::with_capacity(batch_size.min(1024)),
800 exhausted: false,
801 closed: false,
802 enable_logging,
803 }
804 }
805
806 pub fn batch_size(&self) -> usize {
808 self.batch_size
809 }
810
811 pub async fn next(&mut self) -> Result<Option<sqlx::postgres::PgRow>, DbError> {
813 loop {
814 if let Some(row) = self.buffer.pop_front() {
815 return Ok(Some(row));
816 }
817 if self.exhausted {
818 self.close_inner().await?;
819 return Ok(None);
820 }
821 self.fetch_batch().await?;
822 }
823 }
824
825 pub async fn close(mut self) -> Result<(), DbError> {
827 self.buffer.clear();
828 self.close_inner().await
829 }
830
831 async fn fetch_batch(&mut self) -> Result<(), DbError> {
832 let sql = format!(
833 "FETCH FORWARD {} FROM {}",
834 self.batch_size,
835 crate::postgres::identifier::quote_identifier(&self.cursor_name)?
836 );
837 if self.enable_logging {
838 log::debug!("事务内游标拉取: {}", sql);
839 }
840 let rows = sqlx::query(&sql).fetch_all(&mut *self.conn).await?;
841 if rows.len() < self.batch_size {
842 self.exhausted = true;
843 }
844 self.buffer.extend(rows);
845 Ok(())
846 }
847
848 async fn close_inner(&mut self) -> Result<(), DbError> {
849 if self.closed {
850 return Ok(());
851 }
852 self.closed = true;
853 self.exhausted = true;
854 let sql = format!(
855 "CLOSE {}",
856 crate::postgres::identifier::quote_identifier(&self.cursor_name)?
857 );
858 sqlx::query(&sql).execute(&mut *self.conn).await?;
859 Ok(())
860 }
861}
862
863fn bind_json_param_tx<'q>(
864 query: sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments>,
865 param: &serde_json::Value,
866) -> sqlx::query::Query<'q, sqlx::Postgres, sqlx::postgres::PgArguments> {
867 match param {
868 serde_json::Value::String(value) => query.bind(value.clone()),
869 serde_json::Value::Number(value) => match crate::json_param::classify_json_number(value) {
870 Some(crate::json_param::JsonNumber::Int(i)) => query.bind(i),
871 Some(crate::json_param::JsonNumber::Uint(u)) => query.bind(u.to_string()),
872 Some(crate::json_param::JsonNumber::Float(f)) => query.bind(f),
873 None => query.bind(PgUntypedNull),
874 },
875 serde_json::Value::Bool(value) => query.bind(*value),
876 serde_json::Value::Null => query.bind(PgUntypedNull),
877 other => query.bind(other.clone()),
878 }
879}
880
881fn bind_json_param_as_tx<'q, T>(
882 query: sqlx::query::QueryAs<'q, sqlx::Postgres, T, sqlx::postgres::PgArguments>,
883 param: &serde_json::Value,
884) -> sqlx::query::QueryAs<'q, sqlx::Postgres, T, sqlx::postgres::PgArguments>
885where
886 T: for<'row> sqlx::FromRow<'row, sqlx::postgres::PgRow>,
887{
888 match param {
889 serde_json::Value::String(value) => query.bind(value.clone()),
890 serde_json::Value::Number(value) => match crate::json_param::classify_json_number(value) {
891 Some(crate::json_param::JsonNumber::Int(i)) => query.bind(i),
892 Some(crate::json_param::JsonNumber::Uint(u)) => query.bind(u.to_string()),
893 Some(crate::json_param::JsonNumber::Float(f)) => query.bind(f),
894 None => query.bind(PgUntypedNull),
895 },
896 serde_json::Value::Bool(value) => query.bind(*value),
897 serde_json::Value::Null => query.bind(PgUntypedNull),
898 other => query.bind(other.clone()),
899 }
900}
901
902#[cfg(test)]
903#[allow(clippy::unwrap_used, clippy::expect_used)]
904mod tests {
905 use super::*;
906
907 #[test]
908 fn transaction_options_default_emits_no_set_transaction() {
909 assert_eq!(TransactionOptions::default().set_transaction_sql(), None);
910 assert_eq!(TransactionOptions::new().set_transaction_sql(), None);
911 }
912
913 #[test]
914 fn transaction_options_renders_isolation_read_only_and_deferrable() {
915 let isolation_only =
916 TransactionOptions::default().with_isolation(IsolationLevel::Serializable);
917 assert_eq!(
918 isolation_only.set_transaction_sql().as_deref(),
919 Some("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE")
920 );
921
922 assert_eq!(
923 TransactionOptions::read_only()
924 .set_transaction_sql()
925 .as_deref(),
926 Some("SET TRANSACTION READ ONLY")
927 );
928
929 let full = TransactionOptions::default()
930 .with_isolation(IsolationLevel::RepeatableRead)
931 .with_read_only(true)
932 .with_deferrable(true);
933 assert_eq!(
934 full.set_transaction_sql().as_deref(),
935 Some("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ ONLY, DEFERRABLE")
936 );
937 }
938
939 #[test]
940 fn savepoint_statements_quote_names_and_reject_injection() {
941 assert_eq!(
942 savepoint_statement("SAVEPOINT", "sp_1").unwrap(),
943 "SAVEPOINT \"sp_1\""
944 );
945 assert_eq!(
946 savepoint_statement("ROLLBACK TO SAVEPOINT", "sp_1").unwrap(),
947 "ROLLBACK TO SAVEPOINT \"sp_1\""
948 );
949 assert_eq!(
950 savepoint_statement("RELEASE SAVEPOINT", "sp_1").unwrap(),
951 "RELEASE SAVEPOINT \"sp_1\""
952 );
953
954 for invalid in ["", "1sp", "sp; DROP TABLE t"] {
955 assert!(
956 matches!(
957 savepoint_statement("SAVEPOINT", invalid),
958 Err(DbError::InvalidArgument(_))
959 ),
960 "保存点名应拒绝 {invalid:?}"
961 );
962 }
963
964 assert_eq!(
966 savepoint_statement("SAVEPOINT", "sp\"x").unwrap(),
967 "SAVEPOINT \"sp\"\"x\""
968 );
969 }
970
971 #[test]
973 fn advisory_xact_lock_sql_covers_shared_and_exclusive() {
974 assert_eq!(XACT_LOCK_SQL, "SELECT pg_advisory_xact_lock($1)");
975 assert_eq!(
976 XACT_LOCK_SHARED_SQL,
977 "SELECT pg_advisory_xact_lock_shared($1)"
978 );
979 assert_eq!(XACT_TRY_LOCK_SQL, "SELECT pg_try_advisory_xact_lock($1)");
980 assert_eq!(
981 XACT_TRY_LOCK_SHARED_SQL,
982 "SELECT pg_try_advisory_xact_lock_shared($1)"
983 );
984 }
985
986 #[test]
987 fn stream_sql_is_normalized_and_empty_is_rejected() {
988 assert_eq!(normalize_stream_sql(" SELECT 1; ").unwrap(), "SELECT 1");
989 assert_eq!(normalize_stream_sql("SELECT 1;;").unwrap(), "SELECT 1");
990 assert!(matches!(
991 normalize_stream_sql(" ; "),
992 Err(DbError::InvalidArgument(_))
993 ));
994 }
995
996 #[test]
997 fn cursor_names_are_unique_and_identifier_safe() {
998 let first = next_cursor_name();
999 let second = next_cursor_name();
1000 assert_ne!(first, second);
1001 assert!(crate::postgres::identifier::is_valid_identifier(&first));
1002 assert!(crate::postgres::identifier::is_valid_identifier(&second));
1003 }
1004
1005 #[test]
1006 fn guc_names_allow_dotted_identifiers_and_reject_injection() {
1007 assert_eq!(quote_guc_name("app.tenant_id").unwrap(), "'app.tenant_id'");
1008 assert_eq!(
1009 quote_guc_name("statement_timeout").unwrap(),
1010 "'statement_timeout'"
1011 );
1012
1013 for invalid in [
1014 "",
1015 ".app",
1016 "app.",
1017 "app..tenant",
1018 "a.b.c.d",
1019 "app.tenant_id = 'x'",
1020 "app.tenant_id; DROP TABLE t",
1021 "app tenant",
1022 "app\"tenant\"",
1023 ] {
1024 assert!(
1025 matches!(quote_guc_name(invalid), Err(DbError::InvalidArgument(_))),
1026 "GUC 名应拒绝 {invalid:?}"
1027 );
1028 }
1029 }
1030
1031 #[test]
1032 fn prepared_gid_validation_is_strict_whitelist() {
1033 assert!(validate_prepared_gid("phase_c_gid-1.2:3").is_ok());
1034 assert!(validate_prepared_gid(&"a".repeat(MAX_PREPARED_GID_BYTES)).is_ok());
1035
1036 for invalid in [
1037 "",
1038 "gid with space",
1039 "gid'; DROP TABLE t; --",
1040 "gid\"x",
1041 "gid\nx",
1042 ] {
1043 assert!(
1044 matches!(
1045 validate_prepared_gid(invalid),
1046 Err(DbError::InvalidArgument(_))
1047 ),
1048 "GID 应拒绝 {invalid:?}"
1049 );
1050 }
1051 assert!(matches!(
1052 validate_prepared_gid(&"a".repeat(MAX_PREPARED_GID_BYTES + 1)),
1053 Err(DbError::InvalidArgument(_))
1054 ));
1055 }
1056
1057 #[test]
1058 fn lock_table_statement_quotes_table_and_uses_controlled_mode() {
1059 assert_eq!(
1060 lock_table_statement("phase_c.locks", TableLockMode::AccessExclusive).unwrap(),
1061 "LOCK TABLE \"phase_c\".\"locks\" IN ACCESS EXCLUSIVE MODE"
1062 );
1063 assert_eq!(
1064 lock_table_statement("locks", TableLockMode::ShareRowExclusive).unwrap(),
1065 "LOCK TABLE \"locks\" IN SHARE ROW EXCLUSIVE MODE"
1066 );
1067 assert!(matches!(
1068 lock_table_statement("locks; DROP TABLE t", TableLockMode::Share),
1069 Err(DbError::InvalidArgument(_))
1070 ));
1071
1072 let modes = [
1073 (TableLockMode::AccessShare, "ACCESS SHARE"),
1074 (TableLockMode::RowShare, "ROW SHARE"),
1075 (TableLockMode::RowExclusive, "ROW EXCLUSIVE"),
1076 (
1077 TableLockMode::ShareUpdateExclusive,
1078 "SHARE UPDATE EXCLUSIVE",
1079 ),
1080 (TableLockMode::Share, "SHARE"),
1081 (TableLockMode::ShareRowExclusive, "SHARE ROW EXCLUSIVE"),
1082 (TableLockMode::Exclusive, "EXCLUSIVE"),
1083 (TableLockMode::AccessExclusive, "ACCESS EXCLUSIVE"),
1084 ];
1085 for (mode, expected) in modes {
1086 assert_eq!(mode.as_sql(), expected);
1087 }
1088 }
1089}