squawk-cli 2.67.0__tar.gz → 2.68.0__tar.gz

{squawk_cli-2.67.0 → squawk_cli-2.68.0}/Cargo.lock

@@ -2413,7 +2413,7 @@ dependencies = [
 
 [[package]]
 name = "squawk"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "annotate-snippets",
  "anyhow",
@@ -2443,7 +2443,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-fmt"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "annotate-snippets",
  "anyhow",
@@ -2462,7 +2462,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-github"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "jsonwebtoken",
  "log",
@@ -2473,7 +2473,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-ide"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "annotate-snippets",
  "etcetera",
@@ -2496,14 +2496,14 @@ dependencies = [
 
 [[package]]
 name = "squawk-lexer"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "insta",
 ]
 
 [[package]]
 name = "squawk-line-index"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "insta",
  "memchr",
@@ -2514,7 +2514,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-linter"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "annotate-snippets",
  "enum-iterator",
@@ -2530,7 +2530,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-parser"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "annotate-snippets",
  "camino",
@@ -2543,7 +2543,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-server"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "anyhow",
  "crossbeam-channel",
@@ -2571,7 +2571,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-syntax"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "annotate-snippets",
  "camino",
@@ -2587,7 +2587,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-thread"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-utils",
@@ -2599,7 +2599,7 @@ dependencies = [
 
 [[package]]
 name = "squawk-wasm"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -3477,7 +3477,7 @@ checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547"
 
 [[package]]
 name = "xtask"
-version = "2.67.0"
+version = "2.68.0"
 dependencies = [
  "annotate-snippets",
  "anyhow",

{squawk_cli-2.67.0 → squawk_cli-2.68.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "2.67.0"
+version = "2.68.0"
 edition = "2024"
 rust-version = "1.94"
 authors = ["Squawk Team & Contributors"]
@@ -83,16 +83,16 @@ rustc-hash = "2.1.1"
 
 # local
 # we have to make the versions explicit otherwise `cargo publish` won't work
-squawk-fmt = { path = "./crates/squawk_fmt", version = "2.67.0" }
-squawk-github = { path = "./crates/squawk_github", version = "2.67.0" }
-squawk-ide = { path = "./crates/squawk_ide", version = "2.67.0" }
-squawk-lexer = { path = "./crates/squawk_lexer", version = "2.67.0" }
+squawk-fmt = { path = "./crates/squawk_fmt", version = "2.68.0" }
+squawk-github = { path = "./crates/squawk_github", version = "2.68.0" }
+squawk-ide = { path = "./crates/squawk_ide", version = "2.68.0" }
+squawk-lexer = { path = "./crates/squawk_lexer", version = "2.68.0" }
 squawk-line-index = { path = "./crates/squawk_line_index", version = "2.61.0" }
-squawk-parser = { path = "./crates/squawk_parser", version = "2.67.0" }
-squawk-syntax = { path = "./crates/squawk_syntax", version = "2.67.0" }
-squawk-linter = { path = "./crates/squawk_linter", version = "2.67.0" }
-squawk-server = { path = "./crates/squawk_server", version = "2.67.0" }
-squawk-thread = { path = "./crates/squawk_thread", version = "2.67.0" }
+squawk-parser = { path = "./crates/squawk_parser", version = "2.68.0" }
+squawk-syntax = { path = "./crates/squawk_syntax", version = "2.68.0" }
+squawk-linter = { path = "./crates/squawk_linter", version = "2.68.0" }
+squawk-server = { path = "./crates/squawk_server", version = "2.68.0" }
+squawk-thread = { path = "./crates/squawk_thread", version = "2.68.0" }
 
 [workspace.lints.clippy]
 collapsible_else_if = "allow"

{squawk_cli-2.67.0 → squawk_cli-2.68.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squawk-cli
-Version: 2.67.0
+Version: 2.68.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS

{squawk_cli-2.67.0 → squawk_cli-2.68.0}/crates/squawk/README.md

@@ -265,7 +265,7 @@ to your project's `.pre-commit-config.yaml`:
 ```yaml
 repos:
   - repo: https://github.com/sbdchd/squawk
-    rev: v2.67.0
+    rev: v2.68.0
     hooks:
       - id: squawk
         files: path/to/postgres/migrations/written/in/sql

{squawk_cli-2.67.0 → squawk_cli-2.68.0}/crates/squawk_github/src/app.rs

@@ -11,7 +11,7 @@ use serde_json::Value;
 use std::time::Duration;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-pub(crate) const SQUAWK_USER_AGENT: &str = "squawk/2.67.0";
+pub(crate) const SQUAWK_USER_AGENT: &str = "squawk/2.68.0";
 
 #[derive(Debug, Serialize)]
 struct CommentBody {

{squawk_cli-2.67.0 → squawk_cli-2.68.0}/crates/squawk_linter/src/ignore.rs

@@ -278,7 +278,7 @@ alter table t drop column c cascade;
 alter table t add column c char;
 
 ALTER TABLE foo
--- squawk-ignore adding-field-with-default,prefer-robust-stmts
+-- squawk-ignore adding-field-with-default,prefer-robust-stmts,ban-alter-generated-expression
 ADD COLUMN bar numeric GENERATED 
   ALWAYS AS (bar + baz) STORED;
 

{squawk_cli-2.67.0 → squawk_cli-2.68.0}/crates/squawk_linter/src/lib.rs

@@ -19,6 +19,7 @@ pub use version::Version;
 pub mod analyze;
 pub mod ignore;
 mod ignore_index;
+mod name;
 mod version;
 mod visitors;
 
@@ -68,6 +69,13 @@ use rules::require_enum_value_ordering;
 use rules::require_table_schema;
 use rules::require_timeout_settings;
 use rules::transaction_nesting;
+use rules::{
+    ban_alter_generated_expression, ban_alter_identity, ban_disable_trigger, ban_drop_constraint,
+    ban_drop_domain, ban_drop_extension, ban_drop_generated_expression, ban_drop_index,
+    ban_drop_policy, ban_drop_schema, ban_drop_sequence, ban_replace_view_function,
+    ban_replica_identity, ban_revoke, ban_set_default, ban_set_schema,
+    existing_object_compatibility, renaming_object, security_compatibility,
+};
 // xtask:new-rule:rule-import
 
 #[derive(Debug, PartialEq, Clone, Copy, Hash, Eq, Sequence)]
@@ -117,6 +125,39 @@ pub enum Rule {
     BanDropType,
     BanDropDefault,
     BanDropTrigger,
+    BanDropSchema,
+    BanDropSequence,
+    BanDropDomain,
+    BanDropConstraint,
+    BanDropGeneratedExpression,
+    RenamingObject,
+    BanSetSchema,
+    BanAlterIdentity,
+    BanDropExtension,
+    BanAlterGeneratedExpression,
+    BanDropIndex,
+    BanSetDefault,
+    BanDisableTrigger,
+    BanReplicaIdentity,
+    BanDropPolicy,
+    BanRevoke,
+    BanReplaceViewFunction,
+    BanAlterPolicyCondition,
+    BanAlterPolicyRoles,
+    BanCreatePolicy,
+    BanAlterFunctionOptions,
+    BanAlterViewOptions,
+    BanAlterRoleOptions,
+    BanAlterDatabaseOptions,
+    BanAlterRowLevelSecurity,
+    BanNewWriteRestriction,
+    BanAddEnumValue,
+    BanAddCompositeAttribute,
+    BanAddColumn,
+    BanDetachInheritance,
+    BanAlterSequenceValues,
+    BanAlterSystemOptions,
+    BanAlterExtension,
     // xtask:new-rule:error-name
 }
 
@@ -127,7 +168,33 @@ impl Rule {
         // require-timeout-settings is an alias, see `Rule::expands_to`
         matches!(
             self,
-            Rule::RequireTableSchema | Rule::RequireTimeoutSettings | Rule::BanDropTrigger
+            Rule::RequireTableSchema
+                | Rule::RequireTimeoutSettings
+                | Rule::BanDropTrigger
+                | Rule::BanAlterGeneratedExpression
+                | Rule::BanDropIndex
+                | Rule::BanSetDefault
+                | Rule::BanDisableTrigger
+                | Rule::BanReplicaIdentity
+                | Rule::BanDropPolicy
+                | Rule::BanRevoke
+                | Rule::BanReplaceViewFunction
+                | Rule::BanAlterPolicyCondition
+                | Rule::BanAlterPolicyRoles
+                | Rule::BanCreatePolicy
+                | Rule::BanAlterFunctionOptions
+                | Rule::BanAlterViewOptions
+                | Rule::BanAlterRoleOptions
+                | Rule::BanAlterDatabaseOptions
+                | Rule::BanAlterRowLevelSecurity
+                | Rule::BanNewWriteRestriction
+                | Rule::BanAddEnumValue
+                | Rule::BanAddCompositeAttribute
+                | Rule::BanAddColumn
+                | Rule::BanDetachInheritance
+                | Rule::BanAlterSequenceValues
+                | Rule::BanAlterSystemOptions
+                | Rule::BanAlterExtension
         )
     }
 
@@ -195,6 +262,39 @@ impl TryFrom<&str> for Rule {
             "ban-drop-type" => Ok(Rule::BanDropType),
             "ban-drop-default" => Ok(Rule::BanDropDefault),
             "ban-drop-trigger" => Ok(Rule::BanDropTrigger),
+            "ban-drop-schema" => Ok(Rule::BanDropSchema),
+            "ban-drop-sequence" => Ok(Rule::BanDropSequence),
+            "ban-drop-domain" => Ok(Rule::BanDropDomain),
+            "ban-drop-constraint" => Ok(Rule::BanDropConstraint),
+            "ban-drop-generated-expression" => Ok(Rule::BanDropGeneratedExpression),
+            "renaming-object" => Ok(Rule::RenamingObject),
+            "ban-set-schema" => Ok(Rule::BanSetSchema),
+            "ban-alter-identity" => Ok(Rule::BanAlterIdentity),
+            "ban-drop-extension" => Ok(Rule::BanDropExtension),
+            "ban-alter-generated-expression" => Ok(Rule::BanAlterGeneratedExpression),
+            "ban-drop-index" => Ok(Rule::BanDropIndex),
+            "ban-set-default" => Ok(Rule::BanSetDefault),
+            "ban-disable-trigger" => Ok(Rule::BanDisableTrigger),
+            "ban-replica-identity" => Ok(Rule::BanReplicaIdentity),
+            "ban-drop-policy" => Ok(Rule::BanDropPolicy),
+            "ban-revoke" => Ok(Rule::BanRevoke),
+            "ban-replace-view-function" => Ok(Rule::BanReplaceViewFunction),
+            "ban-alter-policy-condition" => Ok(Rule::BanAlterPolicyCondition),
+            "ban-alter-policy-roles" => Ok(Rule::BanAlterPolicyRoles),
+            "ban-create-policy" => Ok(Rule::BanCreatePolicy),
+            "ban-alter-function-options" => Ok(Rule::BanAlterFunctionOptions),
+            "ban-alter-view-options" => Ok(Rule::BanAlterViewOptions),
+            "ban-alter-role-options" => Ok(Rule::BanAlterRoleOptions),
+            "ban-alter-database-options" => Ok(Rule::BanAlterDatabaseOptions),
+            "ban-alter-row-level-security" => Ok(Rule::BanAlterRowLevelSecurity),
+            "ban-new-write-restriction" => Ok(Rule::BanNewWriteRestriction),
+            "ban-add-enum-value" => Ok(Rule::BanAddEnumValue),
+            "ban-add-composite-attribute" => Ok(Rule::BanAddCompositeAttribute),
+            "ban-add-column" => Ok(Rule::BanAddColumn),
+            "ban-detach-inheritance" => Ok(Rule::BanDetachInheritance),
+            "ban-alter-sequence-values" => Ok(Rule::BanAlterSequenceValues),
+            "ban-alter-system-options" => Ok(Rule::BanAlterSystemOptions),
+            "ban-alter-extension" => Ok(Rule::BanAlterExtension),
             // xtask:new-rule:str-name
             _ => Err(format!("Unknown violation name: {s}")),
         }
@@ -271,6 +371,39 @@ impl fmt::Display for Rule {
             Rule::BanDropType => "ban-drop-type",
             Rule::BanDropDefault => "ban-drop-default",
             Rule::BanDropTrigger => "ban-drop-trigger",
+            Rule::BanDropSchema => "ban-drop-schema",
+            Rule::BanDropSequence => "ban-drop-sequence",
+            Rule::BanDropDomain => "ban-drop-domain",
+            Rule::BanDropConstraint => "ban-drop-constraint",
+            Rule::BanDropGeneratedExpression => "ban-drop-generated-expression",
+            Rule::RenamingObject => "renaming-object",
+            Rule::BanSetSchema => "ban-set-schema",
+            Rule::BanAlterIdentity => "ban-alter-identity",
+            Rule::BanDropExtension => "ban-drop-extension",
+            Rule::BanAlterGeneratedExpression => "ban-alter-generated-expression",
+            Rule::BanDropIndex => "ban-drop-index",
+            Rule::BanSetDefault => "ban-set-default",
+            Rule::BanDisableTrigger => "ban-disable-trigger",
+            Rule::BanReplicaIdentity => "ban-replica-identity",
+            Rule::BanDropPolicy => "ban-drop-policy",
+            Rule::BanRevoke => "ban-revoke",
+            Rule::BanReplaceViewFunction => "ban-replace-view-function",
+            Rule::BanAlterPolicyCondition => "ban-alter-policy-condition",
+            Rule::BanAlterPolicyRoles => "ban-alter-policy-roles",
+            Rule::BanCreatePolicy => "ban-create-policy",
+            Rule::BanAlterFunctionOptions => "ban-alter-function-options",
+            Rule::BanAlterViewOptions => "ban-alter-view-options",
+            Rule::BanAlterRoleOptions => "ban-alter-role-options",
+            Rule::BanAlterDatabaseOptions => "ban-alter-database-options",
+            Rule::BanAlterRowLevelSecurity => "ban-alter-row-level-security",
+            Rule::BanNewWriteRestriction => "ban-new-write-restriction",
+            Rule::BanAddEnumValue => "ban-add-enum-value",
+            Rule::BanAddCompositeAttribute => "ban-add-composite-attribute",
+            Rule::BanAddColumn => "ban-add-column",
+            Rule::BanDetachInheritance => "ban-detach-inheritance",
+            Rule::BanAlterSequenceValues => "ban-alter-sequence-values",
+            Rule::BanAlterSystemOptions => "ban-alter-system-options",
+            Rule::BanAlterExtension => "ban-alter-extension",
             // xtask:new-rule:variant-to-name
         };
         write!(f, "{val}")
@@ -540,6 +673,87 @@ impl Linter {
         if self.rules.contains(&Rule::BanDropTrigger) {
             ban_drop_trigger(self, file);
         }
+        if self.rules.contains(&Rule::BanDropSchema) {
+            ban_drop_schema(self, file);
+        }
+        if self.rules.contains(&Rule::BanDropSequence) {
+            ban_drop_sequence(self, file);
+        }
+        if self.rules.contains(&Rule::BanDropDomain) {
+            ban_drop_domain(self, file);
+        }
+        if self.rules.contains(&Rule::BanDropConstraint) {
+            ban_drop_constraint(self, file);
+        }
+        if self.rules.contains(&Rule::BanDropGeneratedExpression) {
+            ban_drop_generated_expression(self, file);
+        }
+        if self.rules.contains(&Rule::RenamingObject) {
+            renaming_object(self, file);
+        }
+        if self.rules.contains(&Rule::BanSetSchema) {
+            ban_set_schema(self, file);
+        }
+        if self.rules.contains(&Rule::BanAlterIdentity) {
+            ban_alter_identity(self, file);
+        }
+        if self.rules.contains(&Rule::BanDropExtension) {
+            ban_drop_extension(self, file);
+        }
+        if self.rules.contains(&Rule::BanAlterGeneratedExpression) {
+            ban_alter_generated_expression(self, file);
+        }
+        if self.rules.contains(&Rule::BanDropIndex) {
+            ban_drop_index(self, file);
+        }
+        if self.rules.contains(&Rule::BanSetDefault) {
+            ban_set_default(self, file);
+        }
+        if self.rules.contains(&Rule::BanDisableTrigger) {
+            ban_disable_trigger(self, file);
+        }
+        if self.rules.contains(&Rule::BanReplicaIdentity) {
+            ban_replica_identity(self, file);
+        }
+        if self.rules.contains(&Rule::BanDropPolicy) {
+            ban_drop_policy(self, file);
+        }
+        if self.rules.contains(&Rule::BanRevoke) {
+            ban_revoke(self, file);
+        }
+        if self.rules.contains(&Rule::BanReplaceViewFunction) {
+            ban_replace_view_function(self, file);
+        }
+        if [
+            Rule::BanCreatePolicy,
+            Rule::BanAlterPolicyRoles,
+            Rule::BanAlterPolicyCondition,
+            Rule::BanAlterFunctionOptions,
+            Rule::BanAlterViewOptions,
+            Rule::BanAlterRoleOptions,
+            Rule::BanAlterDatabaseOptions,
+            Rule::BanAlterSystemOptions,
+            Rule::BanAlterExtension,
+            Rule::BanAlterRowLevelSecurity,
+        ]
+        .iter()
+        .any(|rule| self.rules.contains(rule))
+        {
+            security_compatibility(self, file);
+        }
+        if [
+            Rule::BanNewWriteRestriction,
+            Rule::BanAddEnumValue,
+            Rule::BanAddCompositeAttribute,
+            Rule::BanAddColumn,
+            Rule::BanDetachInheritance,
+            Rule::BanAlterSequenceValues,
+        ]
+        .iter()
+        .any(|rule| self.rules.contains(rule))
+        {
+            existing_object_compatibility(self, file);
+        }
         // xtask:new-rule:rule-call
 
         // locate any ignores in the file
@@ -687,4 +901,69 @@ mod tests {
         assert!(linter.rules.contains(&Rule::RequireLockTimeout));
         assert!(!linter.rules.contains(&Rule::RequireStatementTimeout));
     }
+
+    #[test]
+    fn compatibility_rules_are_enabled_by_default_and_can_be_excluded() {
+        for (rule, sql) in [
+            (Rule::BanDropConstraint, "ALTER TABLE t DROP CONSTRAINT c;"),
+            (
+                Rule::BanAlterIdentity,
+                "ALTER TABLE t ALTER COLUMN id ADD GENERATED ALWAYS AS IDENTITY;",
+            ),
+            (
+                Rule::BanDropGeneratedExpression,
+                "ALTER TABLE t ALTER COLUMN c DROP EXPRESSION;",
+            ),
+            (Rule::BanDropExtension, "DROP EXTENSION hstore;"),
+        ] {
+            let parse = SourceFile::parse(sql);
+            assert!(parse.errors().is_empty());
+            assert!(
+                Linter::with_default_rules()
+                    .lint(&parse, sql)
+                    .iter()
+                    .any(|v| v.code == rule)
+            );
+            assert!(
+                !Linter::with_rules(&[], &[rule])
+                    .lint(&parse, sql)
+                    .iter()
+                    .any(|v| v.code == rule)
+            );
+        }
+    }
+
+    #[test]
+    fn compatibility_rules_require_explicit_configuration() {
+        for (rule, sql) in [
+            (
+                Rule::BanAlterGeneratedExpression,
+                "ALTER TABLE t ALTER COLUMN c SET EXPRESSION AS (id + 1);",
+            ),
+            (Rule::BanAddColumn, "ALTER TABLE t ADD COLUMN c int;"),
+            (Rule::BanReplicaIdentity, "DROP PUBLICATION p;"),
+            (Rule::BanAddEnumValue, "ALTER TYPE mood ADD VALUE 'new';"),
+        ] {
+            let parse = SourceFile::parse(sql);
+            assert!(parse.errors().is_empty());
+            assert!(
+                !Linter::with_default_rules()
+                    .lint(&parse, sql)
+                    .iter()
+                    .any(|v| v.code == rule)
+            );
+            assert!(
+                Linter::with_rules(&[rule], &[])
+                    .lint(&parse, sql)
+                    .iter()
+                    .any(|v| v.code == rule)
+            );
+            assert!(
+                !Linter::with_rules(&[rule], &[rule])
+                    .lint(&parse, sql)
+                    .iter()
+                    .any(|v| v.code == rule)
+            );
+        }
+    }
 }

squawk_cli-2.68.0/crates/squawk_linter/src/name.rs

@@ -0,0 +1,21 @@
+use squawk_syntax::ast::NameLike;
+
+use crate::rules::identifier_too_long::MAX_IDENT_BYTES;
+
+#[derive(Debug, Eq, Hash, PartialEq)]
+pub(crate) struct Name(String);
+
+impl Name {
+    pub(crate) fn from_node(node: &impl NameLike) -> Self {
+        Self::from_string(node.text())
+    }
+
+    pub(crate) fn from_string(mut text: String) -> Self {
+        text.truncate(text.floor_char_boundary(MAX_IDENT_BYTES));
+        Self(text)
+    }
+
+    pub(crate) fn as_str(&self) -> &str {
+        &self.0
+    }
+}

{squawk_cli-2.67.0 → squawk_cli-2.68.0}/crates/squawk_linter/src/rules/adding_not_null_field.rs

@@ -168,6 +168,14 @@ ALTER TABLE "core_recipe" ALTER COLUMN "foo" SET NOT NULL;
         assert_snapshot!(lint_errors(sql, Rule::AddingNotNullableField));
     }
 
+    #[test]
+    fn domain_and_foreign_table_set_not_null_are_not_locking_warnings() {
+        lint_ok(
+            "ALTER DOMAIN d SET NOT NULL; ALTER FOREIGN TABLE ft ALTER COLUMN c SET NOT NULL;",
+            Rule::AddingNotNullableField,
+        );
+    }
+
     #[test]
     fn adding_field_that_is_not_nullable() {
         let sql = r#"

squawk_cli-2.68.0/crates/squawk_linter/src/rules/ban_alter_generated_expression.rs

@@ -0,0 +1,50 @@
+use crate::{Linter, Rule, Violation};
+use squawk_syntax::{
+    Parse, SourceFile,
+    ast::{self, AstNode},
+};
+
+pub(crate) fn ban_alter_generated_expression(ctx: &mut Linter, parse: &Parse<SourceFile>) {
+    for stmt in parse.tree().stmts() {
+        if let ast::Stmt::AlterTable(table) = stmt {
+            for action in table.actions() {
+                match action {
+                    ast::AlterTableAction::AlterColumn(column) => {
+                        if let Some(ast::AlterColumnOption::SetExpression(node)) = column.option() {
+                            ctx.report(Violation::for_node(Rule::BanAlterGeneratedExpression, "Changing a generated column expression may change values read by existing clients.".into(), node.syntax()));
+                        }
+                    }
+                    ast::AlterTableAction::AddColumn(column) => {
+                        for constraint in column.constraints() {
+                            if let ast::Constraint::GeneratedConstraint(node) = constraint {
+                                ctx.report(Violation::for_node(Rule::BanAlterGeneratedExpression, "Adding a generated column may break inserts from existing clients.".into(), node.syntax()));
+                            }
+                        }
+                    }
+                    _ => (),
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{
+        Rule,
+        test_utils::{lint_errors, lint_ok},
+    };
+    use insta::assert_snapshot;
+    #[test]
+    fn err() {
+        let sql = "ALTER TABLE t ALTER COLUMN c SET EXPRESSION AS (id + 2); ALTER TABLE t ADD COLUMN c int GENERATED ALWAYS AS (id + 1) STORED;";
+        assert_snapshot!(lint_errors(sql, Rule::BanAlterGeneratedExpression));
+    }
+    #[test]
+    fn ok() {
+        lint_ok(
+            "ALTER TABLE t ADD COLUMN c int; ALTER TABLE t ALTER COLUMN c DROP EXPRESSION;",
+            Rule::BanAlterGeneratedExpression,
+        );
+    }
+}

squawk_cli-2.68.0/crates/squawk_linter/src/rules/ban_alter_identity.rs

@@ -0,0 +1,70 @@
+use crate::{Linter, Rule, Violation};
+use squawk_syntax::{
+    Parse, SourceFile,
+    ast::{self, AstNode},
+};
+
+pub(crate) fn ban_alter_identity(ctx: &mut Linter, parse: &Parse<SourceFile>) {
+    for stmt in parse.tree().stmts() {
+        if let ast::Stmt::AlterTable(table) = stmt {
+            for action in table.actions() {
+                if let ast::AlterTableAction::AlterColumn(column) = action {
+                    if let Some(option) = column.option() {
+                        match option {
+                            ast::AlterColumnOption::AddGenerated(node) => {
+                                ctx.report(Violation::for_node(Rule::BanAlterIdentity, "Changing column identity may break inserts from existing clients.".into(), node.syntax()));
+                            }
+                            ast::AlterColumnOption::DropIdentity(node) => {
+                                ctx.report(Violation::for_node(Rule::BanAlterIdentity, "Changing column identity may break inserts from existing clients.".into(), node.syntax()));
+                            }
+                            ast::AlterColumnOption::SetGenerated(node)
+                                if matches!(
+                                    node.generated_when(),
+                                    Some(ast::GeneratedWhen::GeneratedAlways(_))
+                                ) =>
+                            {
+                                ctx.report(Violation::for_node(Rule::BanAlterIdentity, "Changing column identity may break inserts from existing clients.".into(), node.syntax()));
+                            }
+                            ast::AlterColumnOption::SetGeneratedOptions(options) => {
+                                for option in options.set_generated_options() {
+                                    if let ast::SetGeneratedOption::SetGenerated(node) = option {
+                                        if matches!(
+                                            node.generated_when(),
+                                            Some(ast::GeneratedWhen::GeneratedAlways(_))
+                                        ) {
+                                            ctx.report(Violation::for_node(Rule::BanAlterIdentity, "Changing column identity may break inserts from existing clients.".into(), node.syntax()));
+                                        }
+                                    }
+                                }
+                            }
+                            _ => (),
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{
+        Rule,
+        test_utils::{lint_errors, lint_ok},
+    };
+    use insta::assert_snapshot;
+    #[test]
+    fn err() {
+        let sql = "ALTER TABLE t ALTER COLUMN id ADD GENERATED ALWAYS AS IDENTITY; ALTER TABLE t ALTER COLUMN id DROP IDENTITY; ALTER TABLE t ALTER COLUMN id SET GENERATED ALWAYS;";
+        let errors = lint_errors(sql, Rule::BanAlterIdentity);
+        assert_eq!(errors.matches("warning[ban-alter-identity]").count(), 3);
+        assert_snapshot!(errors);
+    }
+    #[test]
+    fn ok() {
+        lint_ok(
+            "ALTER TABLE t ALTER COLUMN id SET DEFAULT 1; ALTER TABLE t ALTER COLUMN id SET GENERATED BY DEFAULT;",
+            Rule::BanAlterIdentity,
+        );
+    }
+}