Add GLOBAL context/modifier to SET statements

MohamedAbdeen21 · MohamedAbdeen21 · commit 877758567637 · 2025-03-17T22:52:31.000+02:00
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -37,7 +37,7 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "visitor")]
 use sqlparser_derive::{Visit, VisitMut};
 
-use crate::tokenizer::Span;
+use crate::{keywords::Keyword, tokenizer::Span};
 
 pub use self::data_type::{
     ArrayElemTypeDef, BinaryLength, CharLengthUnits, CharacterLength, DataType, EnumMember,
@@ -2942,7 +2942,7 @@ pub enum Statement {
     /// least MySQL and PostgreSQL. Not all MySQL-specific syntactic forms are
     /// supported yet.
     SetVariable {
-        local: bool,
+        scope: ContextModifier,
         hivevar: bool,
         variables: OneOrManyWithParens<ObjectName>,
         value: Vec<Expr>,
@@ -4649,22 +4649,19 @@ impl fmt::Display for Statement {
                 role_name,
             } => {
                 let role_name = role_name.clone().unwrap_or_else(|| Ident::new("NONE"));
-                write!(f, "SET{context_modifier} ROLE {role_name}")
+                write!(f, "SET {context_modifier}ROLE {role_name}",)
             }
             Statement::SetVariable {
-                local,
+                scope,
                 variables,
                 hivevar,
                 value,
             } => {
                 f.write_str("SET ")?;
-                if *local {
-                    f.write_str("LOCAL ")?;
-                }
                 let parenthesized = matches!(variables, OneOrManyWithParens::Many(_));
                 write!(
                     f,
-                    "{hivevar}{name} = {l_paren}{value}{r_paren}",
+                    "{scope}{hivevar}{name} = {l_paren}{value}{r_paren}",
                     hivevar = if *hivevar { "HIVEVAR:" } else { "" },
                     name = variables,
                     l_paren = parenthesized.then_some("(").unwrap_or_default(),
@@ -7624,6 +7621,8 @@ pub enum ContextModifier {
     Local,
     /// `SESSION` identifier
     Session,
+    /// `GLOBAL` identifier
+    Global,
 }
 
 impl fmt::Display for ContextModifier {
@@ -7633,15 +7632,32 @@ impl fmt::Display for ContextModifier {
                 write!(f, "")
             }
             Self::Local => {
-                write!(f, " LOCAL")
+                write!(f, "LOCAL ")
             }
             Self::Session => {
-                write!(f, " SESSION")
+                write!(f, "SESSION ")
+            }
+            Self::Global => {
+                write!(f, "GLOBAL ")
             }
         }
     }
 }
 
+impl From<Option<Keyword>> for ContextModifier {
+    fn from(kw: Option<Keyword>) -> Self {
+        match kw {
+            Some(kw) => match kw {
+                Keyword::LOCAL => Self::Local,
+                Keyword::SESSION => Self::Session,
+                Keyword::GLOBAL => Self::Global,
+                _ => Self::None,
+            },
+            None => Self::None,
+        }
+    }
+}
+
 /// Function describe in DROP FUNCTION.
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -10944,26 +10944,28 @@ impl<'a> Parser<'a> {
     /// Parse a `SET ROLE` statement. Expects SET to be consumed already.
     fn parse_set_role(&mut self, modifier: Option<Keyword>) -> Result<Statement, ParserError> {
         self.expect_keyword_is(Keyword::ROLE)?;
-        let context_modifier = match modifier {
-            Some(Keyword::LOCAL) => ContextModifier::Local,
-            Some(Keyword::SESSION) => ContextModifier::Session,
-            _ => ContextModifier::None,
-        };
+        let context_modifier = ContextModifier::from(modifier);
 
         let role_name = if self.parse_keyword(Keyword::NONE) {
             None
         } else {
             Some(self.parse_identifier()?)
         };
+
         Ok(Statement::SetRole {
             context_modifier,
             role_name,
         })
     }
 
     pub fn parse_set(&mut self) -> Result<Statement, ParserError> {
-        let modifier =
-            self.parse_one_of_keywords(&[Keyword::SESSION, Keyword::LOCAL, Keyword::HIVEVAR]);
+        let modifier = self.parse_one_of_keywords(&[
+            Keyword::SESSION,
+            Keyword::LOCAL,
+            Keyword::HIVEVAR,
+            Keyword::GLOBAL,
+        ]);
+
         if let Some(Keyword::HIVEVAR) = modifier {
             self.expect_token(&Token::Colon)?;
         } else if let Some(set_role_stmt) =
@@ -11035,7 +11037,7 @@ impl<'a> Parser<'a> {
                     self.expect_token(&Token::RParen)?;
                 }
                 return Ok(Statement::SetVariable {
-                    local: modifier == Some(Keyword::LOCAL),
+                    scope: ContextModifier::from(modifier),
                     hivevar: Some(Keyword::HIVEVAR) == modifier,
                     variables,
                     value: values,
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
@@ -8552,12 +8552,12 @@ fn parse_set_transaction() {
 fn parse_set_variable() {
     match verified_stmt("SET SOMETHING = '1'") {
         Statement::SetVariable {
-            local,
+            scope,
             hivevar,
             variables,
             value,
         } => {
-            assert!(!local);
+            assert_eq!(scope, ContextModifier::None);
             assert!(!hivevar);
             assert_eq!(
                 variables,
@@ -8577,12 +8577,12 @@ fn parse_set_variable() {
     let sql = r#"SET (a, b, c) = (1, 2, 3)"#;
     match multi_variable_dialects.verified_stmt(sql) {
         Statement::SetVariable {
-            local,
+            scope,
             hivevar,
             variables,
             value,
         } => {
-            assert!(!local);
+            assert_eq!(scope, ContextModifier::None);
             assert!(!hivevar);
             assert_eq!(
                 variables,
@@ -8654,12 +8654,12 @@ fn parse_set_variable() {
 fn parse_set_role_as_variable() {
     match verified_stmt("SET role = 'foobar'") {
         Statement::SetVariable {
-            local,
+            scope,
             hivevar,
             variables,
             value,
         } => {
-            assert!(!local);
+            assert_eq!(scope, ContextModifier::None);
             assert!(!hivevar);
             assert_eq!(
                 variables,
@@ -8704,12 +8704,12 @@ fn parse_double_colon_cast_at_timezone() {
 fn parse_set_time_zone() {
     match verified_stmt("SET TIMEZONE = 'UTC'") {
         Statement::SetVariable {
-            local,
+            scope,
             hivevar,
             variables: variable,
             value,
         } => {
-            assert!(!local);
+            assert_eq!(scope, ContextModifier::None);
             assert!(!hivevar);
             assert_eq!(
                 variable,
diff --git a/tests/sqlparser_hive.rs b/tests/sqlparser_hive.rs
@@ -21,10 +21,10 @@
 //! is also tested (on the inputs it can handle).
 
 use sqlparser::ast::{
-    ClusteredBy, CommentDef, CreateFunction, CreateFunctionBody, CreateFunctionUsing, CreateTable,
-    Expr, Function, FunctionArgumentList, FunctionArguments, Ident, ObjectName,
-    OneOrManyWithParens, OrderByExpr, OrderByOptions, SelectItem, Statement, TableFactor,
-    UnaryOperator, Use, Value,
+    ClusteredBy, CommentDef, ContextModifier, CreateFunction, CreateFunctionBody,
+    CreateFunctionUsing, CreateTable, Expr, Function, FunctionArgumentList, FunctionArguments,
+    Ident, ObjectName, OneOrManyWithParens, OrderByExpr, OrderByOptions, SelectItem, Statement,
+    TableFactor, UnaryOperator, Use, Value,
 };
 use sqlparser::dialect::{GenericDialect, HiveDialect, MsSqlDialect};
 use sqlparser::parser::ParserError;
@@ -370,7 +370,7 @@ fn set_statement_with_minus() {
     assert_eq!(
         hive().verified_stmt("SET hive.tez.java.opts = -Xmx4g"),
         Statement::SetVariable {
-            local: false,
+            scope: ContextModifier::None,
             hivevar: false,
             variables: OneOrManyWithParens::One(ObjectName::from(vec![
                 Ident::new("hive"),
diff --git a/tests/sqlparser_mssql.rs b/tests/sqlparser_mssql.rs
@@ -1255,7 +1255,7 @@ fn parse_mssql_declare() {
                 }]
             },
             Statement::SetVariable {
-                local: false,
+                scope: ContextModifier::None,
                 hivevar: false,
                 variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("@bar")])),
                 value: vec![Expr::Value(
diff --git a/tests/sqlparser_mysql.rs b/tests/sqlparser_mysql.rs
@@ -618,7 +618,7 @@ fn parse_set_variables() {
     assert_eq!(
         mysql_and_generic().verified_stmt("SET LOCAL autocommit = 1"),
         Statement::SetVariable {
-            local: true,
+            scope: ContextModifier::Local,
             hivevar: false,
             variables: OneOrManyWithParens::One(ObjectName::from(vec!["autocommit".into()])),
             value: vec![Expr::value(number("1"))],
diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs
@@ -1433,7 +1433,7 @@ fn parse_set() {
     assert_eq!(
         stmt,
         Statement::SetVariable {
-            local: false,
+            scope: ContextModifier::None,
             hivevar: false,
             variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("a")])),
             value: vec![Expr::Identifier(Ident {
@@ -1448,7 +1448,7 @@ fn parse_set() {
     assert_eq!(
         stmt,
         Statement::SetVariable {
-            local: false,
+            scope: ContextModifier::None,
             hivevar: false,
             variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("a")])),
             value: vec![Expr::Value(
@@ -1461,7 +1461,7 @@ fn parse_set() {
     assert_eq!(
         stmt,
         Statement::SetVariable {
-            local: false,
+            scope: ContextModifier::None,
             hivevar: false,
             variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("a")])),
             value: vec![Expr::value(number("0"))],
@@ -1472,7 +1472,7 @@ fn parse_set() {
     assert_eq!(
         stmt,
         Statement::SetVariable {
-            local: false,
+            scope: ContextModifier::None,
             hivevar: false,
             variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("a")])),
             value: vec![Expr::Identifier(Ident::new("DEFAULT"))],
@@ -1483,7 +1483,7 @@ fn parse_set() {
     assert_eq!(
         stmt,
         Statement::SetVariable {
-            local: true,
+            scope: ContextModifier::Local,
             hivevar: false,
             variables: OneOrManyWithParens::One(ObjectName::from(vec![Ident::new("a")])),
             value: vec![Expr::Identifier("b".into())],
@@ -1494,7 +1494,7 @@ fn parse_set() {
     assert_eq!(
         stmt,
         Statement::SetVariable {
-            local: false,
+            scope: ContextModifier::None,
             hivevar: false,
             variables: OneOrManyWithParens::One(ObjectName::from(vec![
                 Ident::new("a"),
@@ -1516,7 +1516,7 @@ fn parse_set() {
     assert_eq!(
         stmt,
         Statement::SetVariable {
-            local: false,
+            scope: ContextModifier::None,
             hivevar: false,
             variables: OneOrManyWithParens::One(ObjectName::from(vec![
                 Ident::new("hive"),
@@ -1530,7 +1530,6 @@ fn parse_set() {
     );
 
     pg_and_generic().one_statement_parses_to("SET a TO b", "SET a = b");
-    pg_and_generic().one_statement_parses_to("SET SESSION a = b", "SET a = b");
 
     assert_eq!(
         pg_and_generic().parse_sql_statements("SET"),
