Support basic CREATE VIEW

src/dialect/keywords.rs

@@ -350,6 +350,7 @@ keyword!(
     VARCHAR,
     VARYING,
     VERSIONING,
+    VIEW,
     WHEN,
     WHENEVER,
     WHERE,
@@ -697,6 +698,7 @@ pub const ALL_KEYWORDS: &'static [&'static str] = &[
     VARCHAR,
     VARYING,
     VERSIONING,
+    VIEW,
     WHEN,
     WHENEVER,
     WHERE,

src/sqlast/mod.rs

@@ -173,6 +173,12 @@ pub enum SQLStatement {
         /// WHERE
         selection: Option<ASTNode>,
     },
+    /// CREATE VIEW
+    SQLCreateView {
+        /// View name
+        name: SQLObjectName,
+        query: SQLSelect,
+    },
     /// CREATE TABLE
     SQLCreateTable {
         /// Table name
@@ -278,6 +284,9 @@ impl ToString for SQLStatement {
                 }
                 s
             }
+            SQLStatement::SQLCreateView { name, query } => {
+                format!("CREATE VIEW {} AS {}", name.to_string(), query.to_string())
+            }
             SQLStatement::SQLCreateTable { name, columns } => format!(
                 "CREATE TABLE {} ({})",
                 name.to_string(),

src/sqlparser.rs

@@ -546,7 +546,33 @@ impl Parser {
 
     /// Parse a SQL CREATE statement
     pub fn parse_create(&mut self) -> Result<SQLStatement, ParserError> {
-        if self.parse_keywords(vec!["TABLE"]) {
+        if self.parse_keyword("TABLE") {
+            self.parse_create_table()
+        } else if self.parse_keyword("VIEW") {
+            self.parse_create_view()
+        } else {
+            parser_err!(format!(
+                "Unexpected token after CREATE: {:?}",
+                self.peek_token()
+            ))
+        }
+    }
+
+    pub fn parse_create_view(&mut self) -> Result<SQLStatement, ParserError> {
+        // Many dialects support `OR REPLACE` | `OR ALTER` right after `CREATE`, but we don't (yet).
+        // ANSI SQL and Postgres support RECURSIVE here, but we don't support it either.
+        let name = self.parse_object_name()?;
+        // Parenthesized "output" columns list could be handled here.
+        // Some dialects allow WITH here, followed by some keywords (e.g. MS SQL)
+        // or `(k1=v1, k2=v2, ...)` (Postgres)
+        self.expect_keyword("AS")?;
+        self.expect_keyword("SELECT")?;
+        let query = self.parse_select()?;
+        // Optional `WITH [ CASCADED | LOCAL ] CHECK OPTION` is widely supported here.
+        Ok(SQLStatement::SQLCreateView { name, query })
+    }
+
+    pub fn parse_create_table(&mut self) -> Result<SQLStatement, ParserError> {
         let table_name = self.parse_object_name()?;
         // parse optional column list (schema)
         let mut columns = vec![];
@@ -586,17 +612,15 @@ impl Parser {
                                 break;
                             }
                             other => {
-                                    return parser_err!(
+                                return parser_err!(format!(
-                                    format!("Expected ',' or ')' after column definition but found {:?}", other)
+                                    "Expected ',' or ')' after column definition but found {:?}",
-                                );
+                                    other
+                                ));
                             }
                         }
                     }
                     unexpected => {
-                            return parser_err!(format!(
+                        return parser_err!(format!("Expected column name, got {:?}", unexpected));
-                                "Expected column name, got {:?}",
-                                unexpected
-                            ));
                     }
                 }
             }
@@ -605,12 +629,6 @@ impl Parser {
             name: table_name,
             columns,
         })
-        } else {
-            parser_err!(format!(
-                "Unexpected token after CREATE: {:?}",
-                self.peek_token()
-            ))
-        }
     }
 
     pub fn parse_table_key(&mut self, constraint_name: SQLIdent) -> Result<TableKey, ParserError> {

tests/sqlparser_generic.rs

@@ -700,6 +700,18 @@ fn parse_scalar_subqueries() {
     };
 }
 
+#[test]
+fn parse_create_view() {
+    let sql = "CREATE VIEW myschema.myview AS SELECT foo FROM bar";
+    match verified_stmt(sql) {
+        SQLStatement::SQLCreateView { name, query } => {
+            assert_eq!("myschema.myview", name.to_string());
+            assert_eq!("SELECT foo FROM bar", query.to_string());
+        }
+        _ => assert!(false),
+    }
+}
+
 #[test]
 fn parse_invalid_subquery_without_parens() {
     let res = parse_sql_statements("SELECT SELECT 1 FROM bar WHERE 1=1 FROM baz");