Code review comments

Author: yoavcloud

src/ast/mod.rs

@@ -7354,6 +7354,9 @@ impl Display for UtilityOption {
     }
 }
 
+/// Represents the different options available for a SHOW <OBJECT>
+/// statement to filter the results. Example from Snowflake:
+/// https://docs.snowflake.com/en/sql-reference/sql/show-tables
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 pub struct ShowStatementOptions {
     pub show_in: Option<ShowStatementIn>,
@@ -7365,7 +7368,7 @@ pub struct ShowStatementOptions {
 
 impl Display for ShowStatementOptions {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let (life_in_infix, like_in_suffix) = match &self.filter_position {
+        let (like_in_infix, like_in_suffix) = match &self.filter_position {
             Some(ShowStatementFilterPosition::Infix(filter)) => {
                 (format!(" {filter}"), "".to_string())
             }
@@ -7376,7 +7379,7 @@ impl Display for ShowStatementOptions {
         };
         write!(
             f,
-            "{life_in_infix}{show_in}{starts_with}{limit}{from}{like_in_suffix}",
+            "{like_in_infix}{show_in}{starts_with}{limit}{from}{like_in_suffix}",
             show_in = match &self.show_in {
                 Some(i) => format!(" {i}"),
                 None => String::new(),

src/keywords.rs

@@ -92,6 +92,7 @@ define_keywords!(
     AND,
     ANTI,
     ANY,
+    APPLICATION,
     APPLY,
     ARCHIVE,
     ARE,

src/parser/mod.rs

@@ -3195,6 +3195,22 @@ impl<'a> Parser<'a> {
             })
     }
 
+    /// Look for all of the expected keywords in sequence, without consuming them
+    fn peek_keyword(&mut self, expected: Keyword) -> bool {
+        let index = self.index;
+        let matched = self.parse_keyword(expected);
+        self.index = index;
+        matched
+    }
+
+    /// Look for all of the expected keywords in sequence, without consuming them
+    fn peek_keywords(&mut self, expected: &[Keyword]) -> bool {
+        let index = self.index;
+        let matched = self.parse_keywords(expected);
+        self.index = index;
+        matched
+    }
+
     /// Return the first non-whitespace token that has not yet been processed
     /// (or None if reached end-of-file) and mark it as processed. OK to call
     /// repeatedly after reaching EOF.
@@ -12311,19 +12327,6 @@ impl<'a> Parser<'a> {
         false
     }
 
-    /// Look for all of the expected keywords in sequence, without consuming them
-    fn peek_keywords(&mut self, expected: &[Keyword]) -> bool {
-        let index = self.index;
-        for kw in expected {
-            if !self.parse_keyword(*kw) {
-                self.index = index;
-                return false;
-            }
-        }
-        self.index = index;
-        true
-    }
-
     fn parse_show_stmt_options(&mut self) -> Result<ShowStatementOptions, ParserError> {
         let show_in;
         let mut filter_position = None;
@@ -12354,7 +12357,8 @@ impl<'a> Parser<'a> {
         let clause = match self.parse_one_of_keywords(&[Keyword::FROM, Keyword::IN]) {
             Some(Keyword::FROM) => ShowStatementInClause::FROM,
             Some(Keyword::IN) => ShowStatementInClause::IN,
-            _ => return Ok(None),
+            None => return Ok(None),
+            _ => return self.expected("FROM or IN", self.peek_token()),
         };
 
         let (parent_type, parent_name) = match self.parse_one_of_keywords(&[
@@ -12364,13 +12368,23 @@ impl<'a> Parser<'a> {
             Keyword::TABLE,
             Keyword::VIEW,
         ]) {
-            Some(Keyword::DATABASE) if self.peek_keywords(&[Keyword::STARTS, Keyword::WITH]) => {
+            // If we see these next keywords it means we don't have a parent name
+            Some(Keyword::DATABASE)
+                if self.peek_keywords(&[Keyword::STARTS, Keyword::WITH])
+                    | self.peek_keyword(Keyword::LIMIT) =>
+            {
                 (Some(ShowStatementInParentType::Database), None)
             }
-            Some(Keyword::SCHEMA) if self.peek_keywords(&[Keyword::STARTS, Keyword::WITH]) => {
+            Some(Keyword::SCHEMA)
+                if self.peek_keywords(&[Keyword::STARTS, Keyword::WITH])
+                    | self.peek_keyword(Keyword::LIMIT) =>
+            {
                 (Some(ShowStatementInParentType::Schema), None)
             }
             Some(parent_kw) => {
+                // The parent name here is still optional, for example: 
+                // SHOW TABLES IN ACCOUNT, so parsing the object name 
+                // may fail because the statement ends.
                 let parent_name = match self.parse_object_name(false) {
                     Ok(n) => Some(n),
                     _ => None,
@@ -12381,7 +12395,12 @@ impl<'a> Parser<'a> {
                     Keyword::SCHEMA => (Some(ShowStatementInParentType::Schema), parent_name),
                     Keyword::TABLE => (Some(ShowStatementInParentType::Table), parent_name),
                     Keyword::VIEW => (Some(ShowStatementInParentType::View), parent_name),
-                    _ => unreachable!(),
+                    _ => {
+                        return self.expected(
+                            "one of ACCOUNT, DATABASE, SCHEMA, TABLE or VIEW",
+                            self.peek_token(),
+                        )
+                    }
                 }
             }
             None => {

tests/sqlparser_snowflake.rs

@@ -2842,7 +2842,7 @@ fn test_show_views() {
 
 #[test]
 fn test_parse_show_columns_sql() {
+    snowflake().verified_stmt("SHOW COLUMNS IN TABLE");
     snowflake().verified_stmt("SHOW COLUMNS IN TABLE abc");
     snowflake().verified_stmt("SHOW COLUMNS LIKE '%xyz%' IN TABLE abc");
-    snowflake().verified_stmt("SHOW COLUMNS IN TABLE");
 }