Parse SUBSTR as alias for SUBSTRING

Author: mvzink

src/ast/mod.rs

@@ -890,6 +890,10 @@ pub enum Expr {
         /// true if the expression is represented using the `SUBSTRING(expr, start, len)` syntax
         /// This flag is used for formatting.
         special: bool,
+
+        /// true if the expression is represented using the `SUBSTR` shorthand
+        /// This flag is used for formatting.
+        shorthand: bool,
     },
     /// ```sql
     /// TRIM([BOTH | LEADING | TRAILING] [<expr> FROM] <expr>)
@@ -1719,8 +1723,13 @@ impl fmt::Display for Expr {
                 substring_from,
                 substring_for,
                 special,
+                shorthand,
             } => {
-                write!(f, "SUBSTRING({expr}")?;
+                f.write_str("SUBSTR")?;
+                if !*shorthand {
+                    f.write_str("ING")?;
+                }
+                write!(f, "({expr}")?;
                 if let Some(from_part) = substring_from {
                     if *special {
                         write!(f, ", {from_part}")?;

src/ast/spans.rs

@@ -1503,6 +1503,7 @@ impl Spanned for Expr {
                 substring_from,
                 substring_for,
                 special: _,
+                shorthand: _,
             } => union_spans(
                 core::iter::once(expr.span())
                     .chain(substring_from.as_ref().map(|i| i.span()))

src/keywords.rs

@@ -841,6 +841,7 @@ define_keywords!(
     STRING,
     STRUCT,
     SUBMULTISET,
+    SUBSTR,
     SUBSTRING,
     SUBSTRING_REGEX,
     SUCCEEDS,

src/parser/mod.rs

@@ -1302,7 +1302,8 @@ impl<'a> Parser<'a> {
             Keyword::POSITION if self.peek_token_ref().token == Token::LParen => {
                 Ok(Some(self.parse_position_expr(w.clone().into_ident(w_span))?))
             }
-            Keyword::SUBSTRING => Ok(Some(self.parse_substring_expr()?)),
+            Keyword::SUBSTR => Ok(Some(self.parse_substring_expr(true)?)),
+            Keyword::SUBSTRING => Ok(Some(self.parse_substring_expr(false)?)),
             Keyword::OVERLAY => Ok(Some(self.parse_overlay_expr()?)),
             Keyword::TRIM => Ok(Some(self.parse_trim_expr()?)),
             Keyword::INTERVAL => Ok(Some(self.parse_interval()?)),
@@ -2403,7 +2404,7 @@ impl<'a> Parser<'a> {
         }
     }
 
-    pub fn parse_substring_expr(&mut self) -> Result<Expr, ParserError> {
+    pub fn parse_substring_expr(&mut self, shorthand: bool) -> Result<Expr, ParserError> {
         // PARSE SUBSTRING (EXPR [FROM 1] [FOR 3])
         self.expect_token(&Token::LParen)?;
         let expr = self.parse_expr()?;
@@ -2424,6 +2425,7 @@ impl<'a> Parser<'a> {
             substring_from: from_expr.map(Box::new),
             substring_for: to_expr.map(Box::new),
             special,
+            shorthand,
         })
     }
 

tests/sqlparser_common.rs

@@ -7607,6 +7607,9 @@ fn parse_substring() {
     verified_stmt("SELECT SUBSTRING('1', 1, 3)");
     verified_stmt("SELECT SUBSTRING('1', 1)");
     verified_stmt("SELECT SUBSTRING('1' FOR 3)");
+    verified_stmt("SELECT SUBSTRING('foo' FROM 1 FOR 2) FROM t");
+    verified_stmt("SELECT SUBSTR('foo' FROM 1 FOR 2) FROM t");
+    verified_stmt("SELECT SUBSTR('foo', 1, 2) FROM t");
 }
 
 #[test]

tests/sqlparser_mssql.rs

@@ -1133,6 +1133,7 @@ fn parse_substring_in_select() {
                                 (number("1")).with_empty_span()
                             ))),
                             special: true,
+                            shorthand: false,
                         })],
                         into: None,
                         from: vec![TableWithJoins {

tests/sqlparser_mysql.rs

@@ -2590,6 +2590,7 @@ fn parse_substring_in_select() {
                                 (number("1")).with_empty_span()
                             ))),
                             special: true,
+                            shorthand: false,
                         })],
                         into: None,
                         from: vec![TableWithJoins {