Add additional cursor parsing support for SQL Server

- parse `OPEN cursor_name` statements
- enable `FETCH` statements to parse `FROM cursor_name`, in addition to the existing `IN` parsing

Author: aharpervc

src/ast/mod.rs

@@ -3032,6 +3032,14 @@ pub enum Statement {
         partition: Option<Box<Expr>>,
     },
     /// ```sql
+    /// OPEN cursor_name
+    /// ```
+    /// Opens a cursor.
+    Open {
+        /// Cursor name
+        cursor_name: Ident,
+    },
+    /// ```sql
     /// CLOSE
     /// ```
     /// Closes the portal underlying an open cursor.
@@ -3403,6 +3411,10 @@ pub enum Statement {
         /// Cursor name
         name: Ident,
         direction: FetchDirection,
+        /// Differentiate between dialects that fetch `FROM` vs fetch `IN`
+        ///
+        /// [MsSql](https://learn.microsoft.com/en-us/sql/t-sql/language-elements/fetch-transact-sql)
+        from_or_in: AttachedToken,
         /// Optional, It's possible to fetch rows form cursor to the table
         into: Option<ObjectName>,
     },
@@ -4225,11 +4237,25 @@ impl fmt::Display for Statement {
             Statement::Fetch {
                 name,
                 direction,
+                from_or_in,
                 into,
             } => {
                 write!(f, "FETCH {direction} ")?;
 
-                write!(f, "IN {name}")?;
+                match &from_or_in.0.token {
+                    Token::Word(w) => match w.keyword {
+                        Keyword::FROM => {
+                            write!(f, "FROM {name}")?;
+                        }
+                        Keyword::IN => {
+                            write!(f, "IN {name}")?;
+                        }
+                        _ => unreachable!(),
+                    },
+                    _ => {
+                        unreachable!()
+                    }
+                }
 
                 if let Some(into) = into {
                     write!(f, " INTO {into}")?;
@@ -4488,6 +4514,11 @@ impl fmt::Display for Statement {
                 Ok(())
             }
             Statement::Delete(delete) => write!(f, "{delete}"),
+            Statement::Open { cursor_name } => {
+                write!(f, "OPEN {cursor_name}")?;
+
+                Ok(())
+            }
             Statement::Close { cursor } => {
                 write!(f, "CLOSE {cursor}")?;
 

src/ast/spans.rs

@@ -364,6 +364,7 @@ impl Spanned for Statement {
                 from_query: _,
                 partition: _,
             } => Span::empty(),
+            Statement::Open { cursor_name } => cursor_name.span,
             Statement::Close { cursor } => match cursor {
                 CloseCursor::All => Span::empty(),
                 CloseCursor::Specific { name } => name.span,

src/parser/mod.rs

@@ -570,6 +570,10 @@ impl<'a> Parser<'a> {
                 Keyword::ALTER => self.parse_alter(),
                 Keyword::CALL => self.parse_call(),
                 Keyword::COPY => self.parse_copy(),
+                Keyword::OPEN => {
+                    self.prev_token();
+                    self.parse_open()
+                }
                 Keyword::CLOSE => self.parse_close(),
                 Keyword::SET => self.parse_set(),
                 Keyword::SHOW => self.parse_show(),
@@ -6609,7 +6613,13 @@ impl<'a> Parser<'a> {
             }
         };
 
-        self.expect_one_of_keywords(&[Keyword::FROM, Keyword::IN])?;
+        let from_or_in_token = if self.peek_keyword(Keyword::FROM) {
+            self.expect_keyword(Keyword::FROM)?
+        } else if self.peek_keyword(Keyword::IN) {
+            self.expect_keyword(Keyword::IN)?
+        } else {
+            return parser_err!("Expected FROM or IN", self.peek_token().span.start);
+        };
 
         let name = self.parse_identifier()?;
 
@@ -6622,6 +6632,7 @@ impl<'a> Parser<'a> {
         Ok(Statement::Fetch {
             name,
             direction,
+            from_or_in: AttachedToken(from_or_in_token),
             into,
         })
     }
@@ -8735,6 +8746,14 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// Parse [Statement::Open]
+    fn parse_open(&mut self) -> Result<Statement, ParserError> {
+        self.expect_keyword(Keyword::OPEN)?;
+        Ok(Statement::Open {
+            cursor_name: self.parse_identifier()?,
+        })
+    }
+
     pub fn parse_close(&mut self) -> Result<Statement, ParserError> {
         let cursor = if self.parse_keyword(Keyword::ALL) {
             CloseCursor::All

tests/sqlparser_mssql.rs

@@ -1393,6 +1393,24 @@ fn parse_mssql_declare() {
     let _ = ms().verified_stmt(declare_cursor_for_select);
 }
 
+#[test]
+fn test_mssql_cursor() {
+    let full_cursor_usage = "\
+        DECLARE Employee_Cursor CURSOR FOR \
+        SELECT LastName, FirstName \
+        FROM AdventureWorks2022.HumanResources.vEmployee \
+        WHERE LastName LIKE 'B%'; \
+        \
+        OPEN Employee_Cursor; \
+        \
+        FETCH NEXT FROM Employee_Cursor; \
+        \
+        CLOSE Employee_Cursor; \
+        DEALLOCATE Employee_Cursor\
+    ";
+    let _ = ms().statements_parse_to(full_cursor_usage, 5, "");
+}
+
 #[test]
 fn test_parse_raiserror() {
     let sql = r#"RAISERROR('This is a test', 16, 1)"#;