Snowflake: Add ALTER EXTERNAL VOLUME

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: sabir-akhadov-localstack

src/ast/mod.rs

@@ -4563,6 +4563,11 @@ pub enum Statement {
     /// See <https://docs.snowflake.com/en/sql-reference/sql/create-external-volume>
     CreateExternalVolume(CreateExternalVolume),
     /// ```sql
+    /// ALTER EXTERNAL VOLUME [IF EXISTS] <name> ...
+    /// ```
+    /// See <https://docs.snowflake.com/en/sql-reference/sql/alter-external-volume>
+    AlterExternalVolume(AlterExternalVolume),
+    /// ```sql
     /// CREATE [ OR REPLACE ] WAREHOUSE [ IF NOT EXISTS ] <name>
     ///   [ [ WITH ] <property> = <value> [ ... ] ]
     /// ```
@@ -6299,6 +6304,7 @@ impl fmt::Display for Statement {
                 Ok(())
             }
             Statement::CreateExternalVolume(s) => write!(f, "{s}"),
+            Statement::AlterExternalVolume(s) => write!(f, "{s}"),
             Statement::CreateWarehouse(s) => write!(f, "{s}"),
             Statement::CopyIntoSnowflake {
                 kind,
@@ -11193,6 +11199,71 @@ impl fmt::Display for CreateExternalVolume {
     }
 }
 
+/// ```sql
+/// ALTER EXTERNAL VOLUME [IF EXISTS] <name> ...
+/// ```
+/// See <https://docs.snowflake.com/en/sql-reference/sql/alter-external-volume>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct AlterExternalVolume {
+    /// External volume name.
+    pub name: ObjectName,
+    /// `IF EXISTS` flag.
+    pub if_exists: bool,
+    /// The alter operation.
+    pub operation: AlterExternalVolumeOperation,
+}
+
+impl fmt::Display for AlterExternalVolume {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "ALTER EXTERNAL VOLUME {if_exists}{name} {operation}",
+            if_exists = if self.if_exists { "IF EXISTS " } else { "" },
+            name = self.name,
+            operation = self.operation,
+        )
+    }
+}
+
+/// Operations for `ALTER EXTERNAL VOLUME`.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum AlterExternalVolumeOperation {
+    /// `ADD STORAGE_LOCATION = ( ... )`
+    AddStorageLocation(KeyValueOptions),
+    /// `SET ALLOW_WRITES = TRUE|FALSE`
+    SetAllowWrites(bool),
+    /// `REMOVE STORAGE_LOCATION '<name>'`
+    RemoveStorageLocation(String),
+}
+
+impl fmt::Display for AlterExternalVolumeOperation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            AlterExternalVolumeOperation::AddStorageLocation(loc) => {
+                write!(f, "ADD STORAGE_LOCATION = ({loc})")
+            }
+            AlterExternalVolumeOperation::SetAllowWrites(val) => {
+                write!(
+                    f,
+                    "SET ALLOW_WRITES = {}",
+                    if *val { "TRUE" } else { "FALSE" }
+                )
+            }
+            AlterExternalVolumeOperation::RemoveStorageLocation(name) => {
+                write!(
+                    f,
+                    "REMOVE STORAGE_LOCATION '{}'",
+                    value::escape_single_quote_string(name)
+                )
+            }
+        }
+    }
+}
+
 /// MSSQL's json null clause
 ///
 /// ```plaintext
@@ -12694,6 +12765,12 @@ impl From<CreateExternalVolume> for Statement {
     }
 }
 
+impl From<AlterExternalVolume> for Statement {
+    fn from(a: AlterExternalVolume) -> Self {
+        Self::AlterExternalVolume(a)
+    }
+}
+
 impl From<CreateWarehouse> for Statement {
     fn from(c: CreateWarehouse) -> Self {
         Self::CreateWarehouse(c)

src/ast/spans.rs

@@ -524,6 +524,7 @@ impl Spanned for Statement {
             Statement::AlterUser(..) => Span::empty(),
             Statement::Reset(..) => Span::empty(),
             Statement::CreateExternalVolume(..) => Span::empty(),
+            Statement::AlterExternalVolume(..) => Span::empty(),
         }
     }
 }

src/dialect/snowflake.rs

@@ -27,15 +27,15 @@ use crate::ast::helpers::stmt_data_loading::{
     FileStagingCommand, StageLoadSelectItem, StageLoadSelectItemKind, StageParamsObject,
 };
 use crate::ast::{
-    AlterTable, AlterTableOperation, AlterTableType, CatalogSyncNamespaceMode, ColumnOption,
-    ColumnPolicy, ColumnPolicyProperty, ContactEntry, CopyIntoSnowflakeKind, CreateExternalVolume,
-    CreateTable, CreateTableLikeKind, DollarQuotedString, Ident, IdentityParameters,
-    IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder,
-    InitializeKind, Insert, MultiTableInsertIntoClause, MultiTableInsertType,
-    MultiTableInsertValue, MultiTableInsertValues, MultiTableInsertWhenClause, ObjectName,
-    ObjectNamePart, RefreshModeKind, RowAccessPolicy, ShowObjects, SqlOption, Statement,
-    StorageLifecyclePolicy, StorageSerializationPolicy, TableObject, TagsColumnOption, Value,
-    WrappedCollection,
+    AlterExternalVolume, AlterExternalVolumeOperation, AlterTable, AlterTableOperation,
+    AlterTableType, CatalogSyncNamespaceMode, ColumnOption, ColumnPolicy, ColumnPolicyProperty,
+    ContactEntry, CopyIntoSnowflakeKind, CreateExternalVolume, CreateTable, CreateTableLikeKind,
+    DollarQuotedString, Ident, IdentityParameters, IdentityProperty, IdentityPropertyFormatKind,
+    IdentityPropertyKind, IdentityPropertyOrder, InitializeKind, Insert,
+    MultiTableInsertIntoClause, MultiTableInsertType, MultiTableInsertValue,
+    MultiTableInsertValues, MultiTableInsertWhenClause, ObjectName, ObjectNamePart,
+    RefreshModeKind, RowAccessPolicy, ShowObjects, SqlOption, Statement, StorageLifecyclePolicy,
+    StorageSerializationPolicy, TableObject, TagsColumnOption, Value, WrappedCollection,
 };
 use crate::dialect::{Dialect, Precedence};
 use crate::keywords::Keyword;
@@ -272,6 +272,11 @@ impl Dialect for SnowflakeDialect {
             return Some(parse_alter_dynamic_table(parser));
         }
 
+        if parser.parse_keywords(&[Keyword::ALTER, Keyword::EXTERNAL, Keyword::VOLUME]) {
+            // ALTER EXTERNAL VOLUME
+            return Some(parse_alter_external_volume(parser));
+        }
+
         if parser.parse_keywords(&[Keyword::ALTER, Keyword::EXTERNAL, Keyword::TABLE]) {
             // ALTER EXTERNAL TABLE
             return Some(parse_alter_external_table(parser));
@@ -2041,6 +2046,40 @@ fn parse_create_external_volume(
     .into())
 }
 
+/// Parse `ALTER EXTERNAL VOLUME [IF EXISTS] <name> ...`
+fn parse_alter_external_volume(parser: &mut Parser) -> Result<Statement, ParserError> {
+    let if_exists = parser.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
+    let name = parser.parse_object_name(false)?;
+
+    let operation = if parser.parse_keyword(Keyword::ADD) {
+        parser.expect_keyword_is(Keyword::STORAGE_LOCATION)?;
+        parser.expect_token(&Token::Eq)?;
+        AlterExternalVolumeOperation::AddStorageLocation(parse_external_volume_storage_location(
+            parser,
+        )?)
+    } else if parser.parse_keyword(Keyword::SET) {
+        parser.expect_keyword_is(Keyword::ALLOW_WRITES)?;
+        parser.expect_token(&Token::Eq)?;
+        AlterExternalVolumeOperation::SetAllowWrites(parser.parse_boolean_string()?)
+    } else if parser.parse_keyword(Keyword::REMOVE) {
+        parser.expect_keyword_is(Keyword::STORAGE_LOCATION)?;
+        let loc_name = parser.parse_literal_string()?;
+        AlterExternalVolumeOperation::RemoveStorageLocation(loc_name)
+    } else {
+        return parser.expected(
+            "ADD, SET, or REMOVE after ALTER EXTERNAL VOLUME <name>",
+            parser.peek_token(),
+        );
+    };
+
+    Ok(AlterExternalVolume {
+        name,
+        if_exists,
+        operation,
+    }
+    .into())
+}
+
 /// Parse one parenthesized storage-location option list, e.g.
 /// `(NAME='loc1' STORAGE_PROVIDER='S3' ...)`. The options (and the
 /// `ENCRYPTION = (...)` sub-list) are parsed generically via

src/keywords.rs

@@ -1007,6 +1007,7 @@ define_keywords!(
     STEP,
     STORAGE,
     STORAGE_INTEGRATION,
+    STORAGE_LOCATION,
     STORAGE_LOCATIONS,
     STORAGE_SERIALIZATION_POLICY,
     STORED,

tests/sqlparser_snowflake.rs

@@ -5249,3 +5249,121 @@ fn test_drop_external_volume_if_exists() {
         _ => unreachable!(),
     }
 }
+
+#[test]
+fn test_alter_external_volume_add_storage_location() {
+    let sql = "ALTER EXTERNAL VOLUME my_vol ADD STORAGE_LOCATION = \
+               (NAME='loc2' STORAGE_PROVIDER='S3' STORAGE_BASE_URL='s3://bucket2/')";
+    match snowflake().verified_stmt(sql) {
+        Statement::AlterExternalVolume(AlterExternalVolume {
+            name,
+            if_exists,
+            operation,
+        }) => {
+            assert_eq!("my_vol", name.to_string());
+            assert!(!if_exists);
+            match operation {
+                AlterExternalVolumeOperation::AddStorageLocation(loc) => {
+                    assert_eq!(Some("loc2"), ext_vol_option(&loc.options, "NAME"));
+                    assert_eq!(Some("S3"), ext_vol_option(&loc.options, "STORAGE_PROVIDER"));
+                }
+                _ => unreachable!(),
+            }
+        }
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn test_alter_external_volume_add_storage_location_full() {
+    // The ADD path reuses the same option parser, so exercise the optional
+    // fields (external id + encryption) through it too.
+    snowflake().verified_stmt(
+        "ALTER EXTERNAL VOLUME my_vol ADD STORAGE_LOCATION = \
+         (NAME='loc2' STORAGE_PROVIDER='S3' STORAGE_BASE_URL='s3://bucket2/' \
+         STORAGE_AWS_ROLE_ARN='arn:aws:iam::role/r' \
+         STORAGE_AWS_EXTERNAL_ID='ext-id' \
+         ENCRYPTION=(TYPE='AWS_SSE_KMS' KMS_KEY_ID='key'))",
+    );
+}
+
+#[test]
+fn test_alter_external_volume_set_allow_writes() {
+    match snowflake().verified_stmt("ALTER EXTERNAL VOLUME my_vol SET ALLOW_WRITES = TRUE") {
+        Statement::AlterExternalVolume(AlterExternalVolume { operation, .. }) => {
+            assert_eq!(
+                AlterExternalVolumeOperation::SetAllowWrites(true),
+                operation
+            );
+        }
+        _ => unreachable!(),
+    }
+
+    match snowflake().verified_stmt("ALTER EXTERNAL VOLUME my_vol SET ALLOW_WRITES = FALSE") {
+        Statement::AlterExternalVolume(AlterExternalVolume { operation, .. }) => {
+            assert_eq!(
+                AlterExternalVolumeOperation::SetAllowWrites(false),
+                operation
+            );
+        }
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn test_alter_external_volume_if_exists() {
+    match snowflake()
+        .verified_stmt("ALTER EXTERNAL VOLUME IF EXISTS my_vol SET ALLOW_WRITES = TRUE")
+    {
+        Statement::AlterExternalVolume(AlterExternalVolume { if_exists, .. }) => {
+            assert!(if_exists);
+        }
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn test_alter_external_volume_remove_storage_location() {
+    match snowflake().verified_stmt("ALTER EXTERNAL VOLUME my_vol REMOVE STORAGE_LOCATION 'loc1'") {
+        Statement::AlterExternalVolume(AlterExternalVolume { operation, .. }) => {
+            assert_eq!(
+                AlterExternalVolumeOperation::RemoveStorageLocation("loc1".to_string()),
+                operation
+            );
+        }
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn test_alter_external_volume_add_empty_storage_location() {
+    let err = snowflake()
+        .parse_sql_statements("ALTER EXTERNAL VOLUME my_vol ADD STORAGE_LOCATION = ()")
+        .expect_err("parser must reject an empty storage location");
+    assert!(
+        err.to_string().contains("storage location options"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn test_alter_external_volume_allow_writes_non_boolean() {
+    let err = snowflake()
+        .parse_sql_statements("ALTER EXTERNAL VOLUME my_vol SET ALLOW_WRITES = 1")
+        .expect_err("parser must reject non-boolean ALLOW_WRITES");
+    assert!(
+        err.to_string().contains("TRUE or FALSE"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn test_alter_external_volume_missing_operation() {
+    let err = snowflake()
+        .parse_sql_statements("ALTER EXTERNAL VOLUME my_vol")
+        .expect_err("parser must reject ALTER EXTERNAL VOLUME without an operation");
+    assert!(
+        err.to_string().contains("ADD, SET, or REMOVE"),
+        "unexpected error: {err}"
+    );
+}