Snowflake: CREATE PROCEDURE EXECUTE AS { CALLER | OWNER }

Author: sabir-akhadov-localstack

src/ast/ddl.rs

@@ -1535,6 +1535,30 @@ impl fmt::Display for ProcedureParam {
     }
 }
 
+/// Snowflake `EXECUTE AS { CALLER | OWNER }` rights on a stored procedure.
+///
+/// When the clause is omitted the procedure runs with owner's rights, so an
+/// absent clause (`None` on `Statement::CreateProcedure`) is equivalent to
+/// `Owner`; `Caller` is the only value that changes the default behaviour.
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum ProcedureExecuteAs {
+    /// `EXECUTE AS CALLER` — run with the caller's rights.
+    Caller,
+    /// `EXECUTE AS OWNER` — run with the owner's rights (Snowflake default).
+    Owner,
+}
+
+impl fmt::Display for ProcedureExecuteAs {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ProcedureExecuteAs::Caller => write!(f, "CALLER"),
+            ProcedureExecuteAs::Owner => write!(f, "OWNER"),
+        }
+    }
+}
+
 /// SQL column definition
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

src/ast/mod.rs

@@ -80,7 +80,8 @@ pub use self::ddl::{
     IdentityPropertyKind, IdentityPropertyOrder, IndexColumn, IndexOption, IndexType,
     KeyOrIndexDisplay, Msck, NullsDistinctOption, OperatorArgTypes, OperatorClassItem,
     OperatorFamilyDropItem, OperatorFamilyItem, OperatorOption, OperatorPurpose, Owner, Partition,
-    PartitionBoundValue, ProcedureParam, ReferentialAction, RenameTableNameKind, ReplicaIdentity,
+    PartitionBoundValue, ProcedureExecuteAs, ProcedureParam, ReferentialAction, RenameTableNameKind,
+    ReplicaIdentity,
     TagsColumnOption, TriggerObjectKind, Truncate, UserDefinedTypeCompositeAttributeDef,
     UserDefinedTypeInternalLength, UserDefinedTypeRangeOption, UserDefinedTypeRepresentation,
     UserDefinedTypeSqlDefinitionOption, UserDefinedTypeStorage, ViewColumnDef,
@@ -4730,6 +4731,11 @@ pub enum Statement {
         returns: Option<DataType>,
         /// Optional language identifier.
         language: Option<Ident>,
+        /// Optional `EXECUTE AS { CALLER | OWNER }` rights clause (Snowflake).
+        ///
+        /// `None` means the clause was omitted, which Snowflake treats as
+        /// owner's rights — i.e. absent is equivalent to `Some(Owner)`.
+        execute_as: Option<ProcedureExecuteAs>,
         /// Procedure body statements.
         body: ConditionalStatements,
     },
@@ -6071,6 +6077,7 @@ impl fmt::Display for Statement {
                 params,
                 returns,
                 language,
+                execute_as,
                 body,
             } => {
                 let modifier = if *or_alter {
@@ -6096,6 +6103,10 @@ impl fmt::Display for Statement {
                     write!(f, " LANGUAGE {language}")?;
                 }
 
+                if let Some(execute_as) = execute_as {
+                    write!(f, " EXECUTE AS {execute_as}")?;
+                }
+
                 write!(f, " AS {body}")
             }
             Statement::CreateMacro {

src/keywords.rs

@@ -196,6 +196,7 @@ define_keywords!(
     CACHE,
     CALL,
     CALLED,
+    CALLER,
     CANONICAL,
     CARDINALITY,
     CASCADE,

src/parser/mod.rs

@@ -20443,6 +20443,21 @@ impl<'a> Parser<'a> {
             None
         };
 
+        // Snowflake's `EXECUTE AS { CALLER | OWNER }` rights clause sits among
+        // the create options before the body `AS`. Only the two-keyword
+        // `EXECUTE AS` sequence is the rights clause; a standalone `AS`
+        // delimits the body below.
+        let execute_as = if self.parse_keywords(&[Keyword::EXECUTE, Keyword::AS]) {
+            if self.parse_keyword(Keyword::CALLER) {
+                Some(ProcedureExecuteAs::Caller)
+            } else {
+                self.expect_keyword_is(Keyword::OWNER)?;
+                Some(ProcedureExecuteAs::Owner)
+            }
+        } else {
+            None
+        };
+
         self.expect_keyword_is(Keyword::AS)?;
 
         // Snowflake encloses the procedure body in a dollar-quoted string
@@ -20466,6 +20481,7 @@ impl<'a> Parser<'a> {
             params,
             returns,
             language,
+            execute_as,
             body,
         })
     }

tests/sqlparser_mssql.rs

@@ -204,6 +204,7 @@ fn parse_create_procedure() {
                 span: Span::empty(),
             }]),
             language: None,
+            execute_as: None,
         }
     )
 }

tests/sqlparser_snowflake.rs

@@ -5405,6 +5405,64 @@ END $$"#;
     assert_eq!(stmts[0], stmts_plain[0]);
 }
 
+/// `EXECUTE AS { CALLER | OWNER }` rights clause parses, is recoverable from
+/// the AST, and round-trips through `Display`. An omitted clause is reported
+/// as owner's-rights (`None`).
+#[test]
+fn test_create_procedure_execute_as() {
+    fn execute_as_of(sql: &str) -> Option<ProcedureExecuteAs> {
+        let stmts = snowflake()
+            .parse_sql_statements(sql)
+            .expect("EXECUTE AS procedure should parse");
+        match &stmts[0] {
+            Statement::CreateProcedure { execute_as, .. } => *execute_as,
+            other => panic!("expected CreateProcedure, got {other:?}"),
+        }
+    }
+
+    let caller = r#"CREATE OR REPLACE PROCEDURE p(a INT) RETURNS VARCHAR LANGUAGE SQL EXECUTE AS CALLER AS $$
+BEGIN
+  RETURN 'x';
+END $$"#;
+    assert_eq!(execute_as_of(caller), Some(ProcedureExecuteAs::Caller));
+
+    let owner = r#"CREATE OR REPLACE PROCEDURE p(a INT) RETURNS VARCHAR LANGUAGE SQL EXECUTE AS OWNER AS $$
+BEGIN
+  RETURN 'x';
+END $$"#;
+    assert_eq!(execute_as_of(owner), Some(ProcedureExecuteAs::Owner));
+
+    let omitted = r#"CREATE OR REPLACE PROCEDURE p(a INT) RETURNS VARCHAR LANGUAGE SQL AS $$
+BEGIN
+  RETURN 'x';
+END $$"#;
+    assert_eq!(execute_as_of(omitted), None);
+
+    // A `CALLER` declaration is distinguishable from `OWNER`/omitted.
+    assert_ne!(execute_as_of(caller), execute_as_of(owner));
+    assert_ne!(execute_as_of(caller), execute_as_of(omitted));
+
+    // parse → Display → parse round-trips for all three forms.
+    for sql in [caller, owner, omitted] {
+        let first = snowflake().parse_sql_statements(sql).unwrap();
+        let rendered = first[0].to_string();
+        let second = snowflake()
+            .parse_sql_statements(&rendered)
+            .expect("re-parse of Display output should succeed");
+        assert_eq!(first[0], second[0]);
+    }
+
+    // The omitted form does not gain a spurious `EXECUTE AS` rendering.
+    let rendered_omitted = snowflake().parse_sql_statements(omitted).unwrap()[0].to_string();
+    assert!(!rendered_omitted.contains("EXECUTE AS"));
+    assert!(snowflake().parse_sql_statements(caller).unwrap()[0]
+        .to_string()
+        .contains("EXECUTE AS CALLER"));
+    assert!(snowflake().parse_sql_statements(owner).unwrap()[0]
+        .to_string()
+        .contains("EXECUTE AS OWNER"));
+}
+
 /// `LET var := expr` (without data type) inside `BEGIN...END`.
 #[test]
 fn test_scripting_let_without_type() {