PostgreSQL: Support column OPTIONS in CREATE FOREIGN TABLE

Author: LucaCappelletti94

fuzz/fuzz_seeds/postgres_foreign_table_column_options.sql

@@ -0,0 +1 @@
+CREATE FOREIGN TABLE ft (id INT OPTIONS (column_name 'remote_id') NOT NULL) SERVER s

src/ast/ddl.rs

@@ -2039,6 +2039,11 @@ pub enum ColumnOption {
     /// [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#view_column_option_list
     /// [2]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#column_option_list
     Options(Vec<SqlOption>),
+    /// PostgreSQL `OPTIONS ( option 'value' [, ...] )` of a column, passed to the
+    /// foreign-data wrapper of a foreign table.
+    ///
+    /// [PostgreSQL](https://www.postgresql.org/docs/current/sql-createforeigntable.html)
+    GenericOptions(Vec<CreateServerOption>),
     /// Creates an identity or an autoincrement column in a table.
     /// Syntax
     /// ```sql
@@ -2212,6 +2217,9 @@ impl fmt::Display for ColumnOption {
             Options(options) => {
                 write!(f, "OPTIONS({})", display_comma_separated(options))
             }
+            GenericOptions(options) => {
+                write!(f, "OPTIONS ({})", display_comma_separated(options))
+            }
             Identity(parameters) => {
                 write!(f, "{parameters}")
             }

src/ast/spans.rs

@@ -900,6 +900,11 @@ impl Spanned for ColumnOption {
             ColumnOption::OnUpdate(expr) => expr.span(),
             ColumnOption::Generated { .. } => Span::empty(),
             ColumnOption::Options(vec) => union_spans(vec.iter().map(|i| i.span())),
+            ColumnOption::GenericOptions(options) => union_spans(
+                options
+                    .iter()
+                    .map(|option| option.key.span.union(&option.value.span)),
+            ),
             ColumnOption::Identity(..) => Span::empty(),
             ColumnOption::OnConflict(..) => Span::empty(),
             ColumnOption::Policy(..) => Span::empty(),

src/dialect/mod.rs

@@ -1568,6 +1568,13 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect supports `OPTIONS ( option 'value' [, ...] )`
+    /// in a column definition.
+    ///
+    /// <https://www.postgresql.org/docs/current/sql-createforeigntable.html>
+    fn supports_column_generic_options(&self) -> bool {
+        false
+    }
     /// Returns true if the specified keyword is reserved and cannot be
     /// used as an identifier without special handling like quoting.
     fn is_reserved_for_identifier(&self, kw: Keyword) -> bool {

src/dialect/postgresql.rs

@@ -587,4 +587,9 @@ impl Dialect for PostgreSqlDialect {
     fn supports_attach_partition_of(&self) -> bool {
         true
     }
+
+    /// See <https://www.postgresql.org/docs/current/sql-createforeigntable.html>
+    fn supports_column_generic_options(&self) -> bool {
+        true
+    }
 }

src/parser/mod.rs

@@ -10323,6 +10323,12 @@ impl<'a> Parser<'a> {
             Ok(Some(ColumnOption::OnUpdate(expr)))
         } else if self.parse_keyword(Keyword::GENERATED) {
             self.parse_optional_column_option_generated()
+        } else if self.dialect.supports_column_generic_options()
+            && self.peek_keyword(Keyword::OPTIONS)
+        {
+            Ok(self
+                .parse_pg_options_clause()?
+                .map(ColumnOption::GenericOptions))
         } else if dialect_of!(self is BigQueryDialect | GenericDialect)
             && self.parse_keyword(Keyword::OPTIONS)
         {
@@ -21354,8 +21360,7 @@ impl<'a> Parser<'a> {
 
     /// Parse a `CREATE FOREIGN TABLE` statement.
     ///
-    /// Per-column `OPTIONS ( ... )`, `INHERITS`, and the `PARTITION OF` form are
-    /// not parsed yet.
+    /// `INHERITS` and the `PARTITION OF` form are not parsed yet.
     ///
     /// See <https://www.postgresql.org/docs/current/sql-createforeigntable.html>
     pub fn parse_create_foreign_table(&mut self) -> Result<CreateForeignTable, ParserError> {

tests/sqlparser_postgres.rs

@@ -11495,3 +11495,61 @@ fn display_create_function_begin_atomic_propagates_write_errors() {
         assert_eq!(write!(writer, "{stmt}"), Err(fmt::Error), "{rejected:?}");
     }
 }
+
+#[test]
+fn parse_column_generic_options() {
+    let sql = r#"CREATE FOREIGN TABLE ft (id INT OPTIONS (column_name 'remote_id') NOT NULL, b TEXT OPTIONS (column_name 'rb', "x" 'y') COLLATE "C") SERVER s"#;
+    let Statement::CreateForeignTable(stmt) = pg().verified_stmt(sql) else {
+        unreachable!()
+    };
+    assert_eq!(
+        stmt.columns[0].options,
+        vec![
+            ColumnOptionDef {
+                name: None,
+                option: ColumnOption::GenericOptions(vec![CreateServerOption {
+                    key: Ident::new("column_name"),
+                    value: Ident::with_quote('\'', "remote_id"),
+                }]),
+            },
+            ColumnOptionDef {
+                name: None,
+                option: ColumnOption::NotNull,
+            },
+        ]
+    );
+    assert_eq!(
+        stmt.columns[1].options[0].option,
+        ColumnOption::GenericOptions(vec![
+            CreateServerOption {
+                key: Ident::new("column_name"),
+                value: Ident::with_quote('\'', "rb"),
+            },
+            CreateServerOption {
+                key: Ident::with_quote('"', "x"),
+                value: Ident::with_quote('\'', "y"),
+            },
+        ])
+    );
+
+    // PostgreSQL rejects column options on a table that is not foreign only at execution.
+    pg().verified_stmt("CREATE TABLE t (id INT OPTIONS (column_name 'remote_id'))");
+    pg().verified_stmt("ALTER TABLE t ADD COLUMN note TEXT OPTIONS (column_name 'memo')");
+
+    for (sql, expected) in [
+        (
+            "CREATE FOREIGN TABLE ft (id INT OPTIONS (column_name)) SERVER s",
+            "Expected: identifier, found: )",
+        ),
+        (
+            "CREATE FOREIGN TABLE ft (id INT OPTIONS ()) SERVER s",
+            "Expected: identifier, found: )",
+        ),
+    ] {
+        assert_eq!(
+            pg().parse_sql_statements(sql).unwrap_err().to_string(),
+            format!("sql parser error: {expected}"),
+            "{sql}"
+        );
+    }
+}