feat(analyser): access exclusive

Author: psteinroe

crates/pgt_analyse/src/analysed_file_context.rs

@@ -41,13 +41,17 @@ impl<'a> AnalysedFileContext<'a> {
 /// This tracks properties that span multiple statements, such as:
 /// - Whether a lock timeout has been set
 /// - Which objects have been created in this transaction
+/// - Whether an ACCESS EXCLUSIVE lock is currently being held
 #[derive(Debug, Default)]
 pub struct TransactionState {
     /// Whether `SET lock_timeout` has been called in this transaction
     lock_timeout_set: bool,
     /// Objects (schema, name) created in this transaction
     /// Schema names are normalized: empty string is stored as "public"
     created_objects: Vec<(String, String)>,
+    /// Whether an ACCESS EXCLUSIVE lock is currently being held
+    /// This is set when an ALTER TABLE is executed on an existing table
+    holding_access_exclusive: bool,
 }
 
 impl TransactionState {
@@ -66,6 +70,11 @@ impl TransactionState {
             .any(|(s, n)| normalized_schema.eq_ignore_ascii_case(s) && name.eq_ignore_ascii_case(n))
     }
 
+    /// Returns true if the transaction is currently holding an ACCESS EXCLUSIVE lock
+    pub fn is_holding_access_exclusive(&self) -> bool {
+        self.holding_access_exclusive
+    }
+
     /// Record that an object was created, normalizing the schema name
     fn add_created_object(&mut self, schema: String, name: String) {
         // Normalize schema: store "public" instead of empty string
@@ -116,5 +125,18 @@ impl TransactionState {
             }
             _ => {}
         }
+
+        // Track ACCESS EXCLUSIVE lock acquisition
+        // ALTER TABLE on an existing table acquires ACCESS EXCLUSIVE lock
+        if let pgt_query::NodeEnum::AlterTableStmt(alter_stmt) = stmt {
+            if let Some(relation) = &alter_stmt.relation {
+                let schema = &relation.schemaname;
+                let name = &relation.relname;
+                // Only set the flag if altering an existing table (not one created in this transaction)
+                if !self.has_created_object(schema, name) {
+                    self.holding_access_exclusive = true;
+                }
+            }
+        }
     }
 }

crates/pgt_analyser/src/lint/safety.rs

@@ -32,5 +32,6 @@ pub mod renaming_column;
 pub mod renaming_table;
 pub mod require_concurrent_index_creation;
 pub mod require_concurrent_index_deletion;
+pub mod running_statement_while_holding_access_exclusive;
 pub mod transaction_nesting;
-declare_lint_group! { pub Safety { name : "safety" , rules : [self :: add_serial_column :: AddSerialColumn , self :: adding_field_with_default :: AddingFieldWithDefault , self :: adding_foreign_key_constraint :: AddingForeignKeyConstraint , self :: adding_not_null_field :: AddingNotNullField , self :: adding_primary_key_constraint :: AddingPrimaryKeyConstraint , self :: adding_required_field :: AddingRequiredField , self :: ban_char_field :: BanCharField , self :: ban_concurrent_index_creation_in_transaction :: BanConcurrentIndexCreationInTransaction , self :: ban_drop_column :: BanDropColumn , self :: ban_drop_database :: BanDropDatabase , self :: ban_drop_not_null :: BanDropNotNull , self :: ban_drop_table :: BanDropTable , self :: ban_truncate_cascade :: BanTruncateCascade , self :: changing_column_type :: ChangingColumnType , self :: constraint_missing_not_valid :: ConstraintMissingNotValid , self :: creating_enum :: CreatingEnum , self :: disallow_unique_constraint :: DisallowUniqueConstraint , self :: lock_timeout_warning :: LockTimeoutWarning , self :: multiple_alter_table :: MultipleAlterTable , self :: prefer_big_int :: PreferBigInt , self :: prefer_bigint_over_int :: PreferBigintOverInt , self :: prefer_bigint_over_smallint :: PreferBigintOverSmallint , self :: prefer_identity :: PreferIdentity , self :: prefer_jsonb :: PreferJsonb , self :: prefer_robust_stmts :: PreferRobustStmts , self :: prefer_text_field :: PreferTextField , self :: prefer_timestamptz :: PreferTimestamptz , self :: renaming_column :: RenamingColumn , self :: renaming_table :: RenamingTable , self :: require_concurrent_index_creation :: RequireConcurrentIndexCreation , self :: require_concurrent_index_deletion :: RequireConcurrentIndexDeletion , self :: transaction_nesting :: TransactionNesting ,] } }
+declare_lint_group! { pub Safety { name : "safety" , rules : [self :: add_serial_column :: AddSerialColumn , self :: adding_field_with_default :: AddingFieldWithDefault , self :: adding_foreign_key_constraint :: AddingForeignKeyConstraint , self :: adding_not_null_field :: AddingNotNullField , self :: adding_primary_key_constraint :: AddingPrimaryKeyConstraint , self :: adding_required_field :: AddingRequiredField , self :: ban_char_field :: BanCharField , self :: ban_concurrent_index_creation_in_transaction :: BanConcurrentIndexCreationInTransaction , self :: ban_drop_column :: BanDropColumn , self :: ban_drop_database :: BanDropDatabase , self :: ban_drop_not_null :: BanDropNotNull , self :: ban_drop_table :: BanDropTable , self :: ban_truncate_cascade :: BanTruncateCascade , self :: changing_column_type :: ChangingColumnType , self :: constraint_missing_not_valid :: ConstraintMissingNotValid , self :: creating_enum :: CreatingEnum , self :: disallow_unique_constraint :: DisallowUniqueConstraint , self :: lock_timeout_warning :: LockTimeoutWarning , self :: multiple_alter_table :: MultipleAlterTable , self :: prefer_big_int :: PreferBigInt , self :: prefer_bigint_over_int :: PreferBigintOverInt , self :: prefer_bigint_over_smallint :: PreferBigintOverSmallint , self :: prefer_identity :: PreferIdentity , self :: prefer_jsonb :: PreferJsonb , self :: prefer_robust_stmts :: PreferRobustStmts , self :: prefer_text_field :: PreferTextField , self :: prefer_timestamptz :: PreferTimestamptz , self :: renaming_column :: RenamingColumn , self :: renaming_table :: RenamingTable , self :: require_concurrent_index_creation :: RequireConcurrentIndexCreation , self :: require_concurrent_index_deletion :: RequireConcurrentIndexDeletion , self :: running_statement_while_holding_access_exclusive :: RunningStatementWhileHoldingAccessExclusive , self :: transaction_nesting :: TransactionNesting ,] } }

crates/pgt_analyser/src/lint/safety/lock_timeout_warning.rs

@@ -38,7 +38,7 @@ declare_lint_rule! {
         version: "next",
         name: "lockTimeoutWarning",
         severity: Severity::Error,
-        recommended: false,
+        recommended: true,
         sources: &[RuleSource::Eugene("E9")],
     }
 }

crates/pgt_analyser/src/lint/safety/running_statement_while_holding_access_exclusive.rs

@@ -0,0 +1,72 @@
+use pgt_analyse::{Rule, RuleDiagnostic, RuleSource, context::RuleContext, declare_lint_rule};
+use pgt_console::markup;
+use pgt_diagnostics::Severity;
+
+declare_lint_rule! {
+    /// Running additional statements while holding an ACCESS EXCLUSIVE lock blocks all table access.
+    ///
+    /// When a transaction acquires an ACCESS EXCLUSIVE lock (e.g., via ALTER TABLE), it blocks all other
+    /// operations on that table, including reads. Running additional statements in the same transaction
+    /// extends the duration the lock is held, potentially blocking all database access to that table.
+    ///
+    /// This is particularly problematic because:
+    /// - The lock blocks all SELECT, INSERT, UPDATE, DELETE operations
+    /// - The lock is held for the entire duration of all subsequent statements
+    /// - Even simple queries like SELECT COUNT(*) can significantly extend lock time
+    ///
+    /// To minimize blocking, run the ALTER TABLE in its own transaction and execute
+    /// other operations in separate transactions.
+    ///
+    /// ## Examples
+    ///
+    /// ### Invalid
+    ///
+    /// ```sql,expect_diagnostic
+    /// ALTER TABLE authors ADD COLUMN email TEXT;
+    /// SELECT COUNT(*) FROM authors;
+    /// ```
+    ///
+    /// ### Valid
+    ///
+    /// ```sql
+    /// -- Run ALTER TABLE alone, other queries in separate transactions
+    /// ALTER TABLE authors ADD COLUMN email TEXT;
+    /// ```
+    ///
+    pub RunningStatementWhileHoldingAccessExclusive {
+        version: "next",
+        name: "runningStatementWhileHoldingAccessExclusive",
+        severity: Severity::Warning,
+        recommended: true,
+        sources: &[RuleSource::Eugene("E4")],
+    }
+}
+
+impl Rule for RunningStatementWhileHoldingAccessExclusive {
+    type Options = ();
+
+    fn run(ctx: &RuleContext<Self>) -> Vec<RuleDiagnostic> {
+        let mut diagnostics = Vec::new();
+
+        // Check if we're currently holding an ACCESS EXCLUSIVE lock
+        let tx_state = ctx.file_context().transaction_state();
+        if tx_state.is_holding_access_exclusive() {
+            diagnostics.push(
+                RuleDiagnostic::new(
+                    rule_category!(),
+                    None,
+                    markup! {
+                        "Running statement while holding ACCESS EXCLUSIVE lock."
+                    },
+                )
+                .detail(
+                    None,
+                    "This blocks all access to the table for the duration of this statement.",
+                )
+                .note("Run this statement in a separate transaction to minimize lock duration."),
+            );
+        }
+
+        diagnostics
+    }
+}

crates/pgt_analyser/src/options.rs

@@ -50,5 +50,6 @@ pub type RenamingTable =
     <lint::safety::renaming_table::RenamingTable as pgt_analyse::Rule>::Options;
 pub type RequireConcurrentIndexCreation = < lint :: safety :: require_concurrent_index_creation :: RequireConcurrentIndexCreation as pgt_analyse :: Rule > :: Options ;
 pub type RequireConcurrentIndexDeletion = < lint :: safety :: require_concurrent_index_deletion :: RequireConcurrentIndexDeletion as pgt_analyse :: Rule > :: Options ;
+pub type RunningStatementWhileHoldingAccessExclusive = < lint :: safety :: running_statement_while_holding_access_exclusive :: RunningStatementWhileHoldingAccessExclusive as pgt_analyse :: Rule > :: Options ;
 pub type TransactionNesting =
     <lint::safety::transaction_nesting::TransactionNesting as pgt_analyse::Rule>::Options;

crates/pgt_analyser/tests/specs/safety/runningStatementWhileHoldingAccessExclusive/basic.sql

@@ -0,0 +1,4 @@
+-- expect_only_lint/safety/runningStatementWhileHoldingAccessExclusive
+-- Running SELECT after ALTER TABLE should trigger the rule
+ALTER TABLE authors ADD COLUMN email TEXT NOT NULL;
+SELECT COUNT(*) FROM authors;

crates/pgt_analyser/tests/specs/safety/runningStatementWhileHoldingAccessExclusive/basic.sql.snap

@@ -0,0 +1,21 @@
+---
+source: crates/pgt_analyser/tests/rules_tests.rs
+expression: snapshot
+snapshot_kind: text
+---
+# Input
+```
+-- expect_only_lint/safety/runningStatementWhileHoldingAccessExclusive
+-- Running SELECT after ALTER TABLE should trigger the rule
+ALTER TABLE authors ADD COLUMN email TEXT NOT NULL;
+SELECT COUNT(*) FROM authors;
+```
+
+# Diagnostics
+lint/safety/runningStatementWhileHoldingAccessExclusive ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Running statement while holding ACCESS EXCLUSIVE lock.
+  
+  i This blocks all access to the table for the duration of this statement.
+  
+  i Run this statement in a separate transaction to minimize lock duration.

crates/pgt_analyser/tests/specs/safety/runningStatementWhileHoldingAccessExclusive/create_index_after_alter.sql

@@ -0,0 +1,4 @@
+-- expect_only_lint/safety/runningStatementWhileHoldingAccessExclusive
+-- CREATE INDEX after ALTER TABLE should trigger
+ALTER TABLE orders ADD COLUMN total DECIMAL(10, 2);
+CREATE INDEX orders_total_idx ON orders(total);

crates/pgt_analyser/tests/specs/safety/runningStatementWhileHoldingAccessExclusive/create_index_after_alter.sql.snap

@@ -0,0 +1,22 @@
+---
+source: crates/pgt_analyser/tests/rules_tests.rs
+expression: snapshot
+snapshot_kind: text
+---
+# Input
+```
+-- expect_only_lint/safety/runningStatementWhileHoldingAccessExclusive
+-- CREATE INDEX after ALTER TABLE should trigger
+ALTER TABLE orders ADD COLUMN total DECIMAL(10, 2);
+CREATE INDEX orders_total_idx ON orders(total);
+
+```
+
+# Diagnostics
+lint/safety/runningStatementWhileHoldingAccessExclusive ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Running statement while holding ACCESS EXCLUSIVE lock.
+  
+  i This blocks all access to the table for the duration of this statement.
+  
+  i Run this statement in a separate transaction to minimize lock duration.

crates/pgt_analyser/tests/specs/safety/runningStatementWhileHoldingAccessExclusive/insert_after_alter.sql

@@ -0,0 +1,4 @@
+-- expect_only_lint/safety/runningStatementWhileHoldingAccessExclusive
+-- INSERT after ALTER TABLE should trigger
+ALTER TABLE books ADD COLUMN isbn TEXT;
+INSERT INTO books (title, isbn) VALUES ('Database Systems', '978-0-1234567-8-9');