Read untyped PARTITION OF columns in CREATE FOREIGN TABLE

Author: LucaCappelletti94

src/ast/spans.rs

@@ -3377,6 +3377,19 @@ SETTINGS update_parallel_mode = 'auto'"#;
         assert_eq!(test.get_source(options[0].value.span), "'public'");
     }
 
+    #[test]
+    fn test_create_foreign_table_partition_of_span() {
+        let dialect = &crate::dialect::PostgreSqlDialect {};
+        let sql =
+            "CREATE FOREIGN TABLE part PARTITION OF root (id NOT NULL) FOR VALUES IN (1) SERVER s";
+        let test = SpanTest::new(dialect, sql);
+        let r = Parser::parse_sql(dialect, sql).unwrap();
+        assert_eq!(
+            test.get_source(r[0].span()),
+            "part PARTITION OF root (id NOT NULL) FOR VALUES IN (1) SERVER s"
+        );
+    }
+
     #[test]
     fn test_alter_table_modify_order_by_span() {
         let dialect = &crate::dialect::ClickHouseDialect {};

src/parser/mod.rs

@@ -21404,13 +21404,16 @@ impl<'a> Parser<'a> {
         } else {
             None
         };
-        if partition_of.is_none() && self.peek_token_ref().token != Token::LParen {
+        let (columns, constraints) = if partition_of.is_some() {
+            self.parse_partition_of_columns()?
+        } else if self.peek_token_ref().token == Token::LParen {
+            self.parse_columns()?
+        } else {
             return self.expected_ref(
                 "'(' before the column list of CREATE FOREIGN TABLE",
                 self.peek_token_ref(),
             );
-        }
-        let (columns, constraints) = self.parse_columns()?;
+        };
         // `INHERITS` belongs to the column-list form only.
         let inherits = if partition_of.is_none() && self.parse_keyword(Keyword::INHERITS) {
             Some(self.parse_parenthesized_qualified_column_list(IsOptional::Mandatory, false)?)

tests/sqlparser_postgres.rs

@@ -11815,7 +11815,17 @@ fn parse_create_foreign_table_partition_of() {
     let Statement::CreateForeignTable(stmt) = pg_and_generic().verified_stmt(sql) else {
         unreachable!()
     };
-    assert_eq!(stmt.columns.len(), 1);
+    assert_eq!(
+        stmt.columns,
+        vec![ColumnDef {
+            name: Ident::new("id"),
+            data_type: DataType::Unspecified,
+            options: vec![ColumnOptionDef {
+                name: None,
+                option: ColumnOption::NotNull,
+            }],
+        }]
+    );
     assert_eq!(stmt.constraints.len(), 1);
     assert_eq!(
         stmt.for_values,
@@ -11834,6 +11844,11 @@ fn parse_create_foreign_table_partition_of() {
         pg_and_generic().verified_stmt(sql);
     }
 
+    pg_and_generic().one_statement_parses_to(
+        "CREATE FOREIGN TABLE part PARTITION OF root (id WITH OPTIONS NOT NULL) DEFAULT SERVER s",
+        "CREATE FOREIGN TABLE part PARTITION OF root (id NOT NULL) DEFAULT SERVER s",
+    );
+
     for (sql, expected) in [
         (
             "CREATE FOREIGN TABLE part PARTITION OF root SERVER s",
@@ -11867,6 +11882,14 @@ fn parse_create_foreign_table_partition_of() {
             "CREATE FOREIGN TABLE part (id INT) PARTITION OF root DEFAULT SERVER s",
             "Expected: SERVER, found: PARTITION",
         ),
+        (
+            "CREATE FOREIGN TABLE part PARTITION OF root (id INT) DEFAULT SERVER s",
+            "Expected: ',' or ')' after column definition, found: INT",
+        ),
+        (
+            "CREATE FOREIGN TABLE part (id) SERVER s",
+            "Expected: a data type name, found: )",
+        ),
     ] {
         assert_eq!(
             pg_and_generic()