Merge pull request #8 from fmguerreiro/feat/foreign-table-fdw

feat: parse CREATE FOREIGN DATA WRAPPER and CREATE FOREIGN TABLE

Author: fmguerreiro

src/ast/ddl.rs

@@ -42,7 +42,8 @@ use crate::ast::{
         UniqueConstraint,
     },
     ArgMode, AttachedToken, CommentDef, ConditionalStatements, CreateFunctionBody,
-    CreateFunctionUsing, CreateTableLikeKind, CreateTableOptions, CreateViewParams, DataType, Expr,
+    CreateFunctionUsing, CreateServerOption, CreateTableLikeKind, CreateTableOptions,
+    CreateViewParams, DataType, Expr,
     FileFormat, FunctionBehavior, FunctionCalledOnNull, FunctionDefinitionSetParam, FunctionDesc,
     FunctionDeterminismSpecifier, FunctionParallel, FunctionSecurity, HiveDistributionStyle,
     HiveFormat, HiveIOFormat, HiveRowFormat, HiveSetLocation, Ident, InitializeKind,
@@ -5758,6 +5759,107 @@ impl From<AlterPolicy> for crate::ast::Statement {
     }
 }
 
+/// The handler/validator clause of a `CREATE FOREIGN DATA WRAPPER` statement.
+///
+/// Specifies either a named function or the absence of a function.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum FdwRoutineClause {
+    /// A named function, e.g. `HANDLER myhandler` or `VALIDATOR myvalidator`.
+    Function(ObjectName),
+    /// The `NO HANDLER` or `NO VALIDATOR` form.
+    NoFunction,
+}
+
+/// A `CREATE FOREIGN DATA WRAPPER` statement.
+///
+/// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createforeigndatawrapper.html)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateForeignDataWrapper {
+    /// The name of the foreign-data wrapper.
+    pub name: Ident,
+    /// Optional `HANDLER handler_function` or `NO HANDLER` clause.
+    pub handler: Option<FdwRoutineClause>,
+    /// Optional `VALIDATOR validator_function` or `NO VALIDATOR` clause.
+    pub validator: Option<FdwRoutineClause>,
+    /// Optional `OPTIONS (key 'value', ...)` clause.
+    pub options: Option<Vec<CreateServerOption>>,
+}
+
+impl fmt::Display for CreateForeignDataWrapper {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "CREATE FOREIGN DATA WRAPPER {}", self.name)?;
+        if let Some(handler) = &self.handler {
+            match handler {
+                FdwRoutineClause::Function(name) => write!(f, " HANDLER {name}")?,
+                FdwRoutineClause::NoFunction => write!(f, " NO HANDLER")?,
+            }
+        }
+        if let Some(validator) = &self.validator {
+            match validator {
+                FdwRoutineClause::Function(name) => write!(f, " VALIDATOR {name}")?,
+                FdwRoutineClause::NoFunction => write!(f, " NO VALIDATOR")?,
+            }
+        }
+        if let Some(options) = &self.options {
+            write!(f, " OPTIONS ({})", display_comma_separated(options))?;
+        }
+        Ok(())
+    }
+}
+
+impl From<CreateForeignDataWrapper> for crate::ast::Statement {
+    fn from(v: CreateForeignDataWrapper) -> Self {
+        crate::ast::Statement::CreateForeignDataWrapper(v)
+    }
+}
+
+/// A `CREATE FOREIGN TABLE` statement.
+///
+/// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createforeigntable.html)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateForeignTable {
+    /// The foreign table name.
+    #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
+    pub name: ObjectName,
+    /// Whether `IF NOT EXISTS` was specified.
+    pub if_not_exists: bool,
+    /// Column definitions.
+    pub columns: Vec<ColumnDef>,
+    /// The `SERVER server_name` clause.
+    pub server_name: Ident,
+    /// Optional `OPTIONS (key 'value', ...)` clause at the table level.
+    pub options: Option<Vec<CreateServerOption>>,
+}
+
+impl fmt::Display for CreateForeignTable {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "CREATE FOREIGN TABLE {if_not_exists}{name} ({columns}) SERVER {server_name}",
+            if_not_exists = if self.if_not_exists { "IF NOT EXISTS " } else { "" },
+            name = self.name,
+            columns = display_comma_separated(&self.columns),
+            server_name = self.server_name,
+        )?;
+        if let Some(options) = &self.options {
+            write!(f, " OPTIONS ({})", display_comma_separated(options))?;
+        }
+        Ok(())
+    }
+}
+
+impl From<CreateForeignTable> for crate::ast::Statement {
+    fn from(v: CreateForeignTable) -> Self {
+        crate::ast::Statement::CreateForeignTable(v)
+    }
+}
+
 /// CREATE AGGREGATE statement.
 /// See <https://www.postgresql.org/docs/current/sql-createaggregate.html>
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

src/ast/mod.rs

@@ -70,12 +70,13 @@ pub use self::ddl::{
     AggregateModifyKind, ClusteredBy, ColumnDef, ColumnOption, ColumnOptionDef, ColumnOptions,
     ColumnPolicy, ColumnPolicyProperty, ConstraintCharacteristics, CreateAggregate,
     CreateAggregateOption, CreateCollation, CreateCollationDefinition, CreateConnector,
-    CreateDomain, CreateExtension, CreateFunction, CreateIndex, CreateOperator, CreateOperatorClass,
-    CreateOperatorFamily, CreatePolicy, CreatePolicyCommand, CreatePolicyType, CreateTable,
-    CreateTextSearchConfiguration, CreateTextSearchDictionary, CreateTextSearchParser,
-    CreateTextSearchTemplate, CreateTrigger, CreateView, Deduplicate, DeferrableInitial, DistStyle,
-    DropBehavior, DropExtension, DropFunction, DropOperator, DropOperatorClass, DropOperatorFamily,
-    DropOperatorSignature, DropPolicy, DropTrigger, ForValues, FunctionReturnType, GeneratedAs,
+    CreateDomain, CreateExtension, CreateForeignDataWrapper, CreateForeignTable, CreateFunction,
+    CreateIndex, CreateOperator, CreateOperatorClass, CreateOperatorFamily, CreatePolicy,
+    CreatePolicyCommand, CreatePolicyType, CreateTable, CreateTextSearchConfiguration,
+    CreateTextSearchDictionary, CreateTextSearchParser, CreateTextSearchTemplate, CreateTrigger,
+    CreateView, Deduplicate, DeferrableInitial, DistStyle, DropBehavior, DropExtension,
+    DropFunction, DropOperator, DropOperatorClass, DropOperatorFamily, DropOperatorSignature,
+    DropPolicy, DropTrigger, FdwRoutineClause, ForValues, FunctionReturnType, GeneratedAs,
     GeneratedExpressionMode, IdentityParameters, IdentityProperty, IdentityPropertyFormatKind,
     IdentityPropertyKind, IdentityPropertyOrder, IndexColumn, IndexOption, IndexType,
     KeyOrIndexDisplay, Msck, NullsDistinctOption, OperatorArgTypes, OperatorClassItem,
@@ -3701,6 +3702,16 @@ pub enum Statement {
     /// A `CREATE SERVER` statement.
     CreateServer(CreateServerStatement),
     /// ```sql
+    /// CREATE FOREIGN DATA WRAPPER
+    /// ```
+    /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createforeigndatawrapper.html)
+    CreateForeignDataWrapper(CreateForeignDataWrapper),
+    /// ```sql
+    /// CREATE FOREIGN TABLE
+    /// ```
+    /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createforeigntable.html)
+    CreateForeignTable(CreateForeignTable),
+    /// ```sql
     /// CREATE POLICY
     /// ```
     /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createpolicy.html)
@@ -5539,6 +5550,8 @@ impl fmt::Display for Statement {
             Statement::CreateServer(stmt) => {
                 write!(f, "{stmt}")
             }
+            Statement::CreateForeignDataWrapper(stmt) => write!(f, "{stmt}"),
+            Statement::CreateForeignTable(stmt) => write!(f, "{stmt}"),
             Statement::CreatePolicy(policy) => write!(f, "{policy}"),
             Statement::CreateConnector(create_connector) => create_connector.fmt(f),
             Statement::CreateOperator(create_operator) => create_operator.fmt(f),

src/ast/spans.rs

@@ -394,6 +394,8 @@ impl Spanned for Statement {
             Statement::DropOperatorClass(drop_operator_class) => drop_operator_class.span(),
             Statement::CreateSecret { .. } => Span::empty(),
             Statement::CreateServer { .. } => Span::empty(),
+            Statement::CreateForeignDataWrapper { .. } => Span::empty(),
+            Statement::CreateForeignTable { .. } => Span::empty(),
             Statement::CreateConnector { .. } => Span::empty(),
             Statement::CreateOperator(create_operator) => create_operator.span(),
             Statement::CreateOperatorFamily(create_operator_family) => {

src/keywords.rs

@@ -478,6 +478,7 @@ define_keywords!(
     GROUPING,
     GROUPS,
     GZIP,
+    HANDLER,
     HASH,
     HASHES,
     HAVING,
@@ -1134,6 +1135,7 @@ define_keywords!(
     VALID,
     VALIDATE,
     VALIDATION_MODE,
+    VALIDATOR,
     VALUE,
     VALUES,
     VALUE_OF,

src/parser/mod.rs

@@ -5215,6 +5215,17 @@ impl<'a> Parser<'a> {
             }
         } else if self.parse_keyword(Keyword::SERVER) {
             self.parse_pg_create_server()
+        } else if self.parse_keyword(Keyword::FOREIGN) {
+            if self.parse_keywords(&[Keyword::DATA, Keyword::WRAPPER]) {
+                self.parse_create_foreign_data_wrapper().map(Into::into)
+            } else if self.parse_keyword(Keyword::TABLE) {
+                self.parse_create_foreign_table().map(Into::into)
+            } else {
+                self.expected_ref(
+                    "DATA WRAPPER or TABLE after CREATE FOREIGN",
+                    self.peek_token_ref(),
+                )
+            }
         } else if self.parse_keywords(&[Keyword::TEXT, Keyword::SEARCH]) {
             self.parse_create_text_search()
         } else {
@@ -19992,6 +20003,86 @@ impl<'a> Parser<'a> {
         }))
     }
 
+    /// Parse a `CREATE FOREIGN DATA WRAPPER` statement.
+    ///
+    /// See <https://www.postgresql.org/docs/current/sql-createforeigndatawrapper.html>
+    pub fn parse_create_foreign_data_wrapper(
+        &mut self,
+    ) -> Result<CreateForeignDataWrapper, ParserError> {
+        let name = self.parse_identifier()?;
+
+        let handler = if self.parse_keyword(Keyword::HANDLER) {
+            Some(FdwRoutineClause::Function(self.parse_object_name(false)?))
+        } else if self.parse_keywords(&[Keyword::NO, Keyword::HANDLER]) {
+            Some(FdwRoutineClause::NoFunction)
+        } else {
+            None
+        };
+
+        let validator = if self.parse_keyword(Keyword::VALIDATOR) {
+            Some(FdwRoutineClause::Function(self.parse_object_name(false)?))
+        } else if self.parse_keywords(&[Keyword::NO, Keyword::VALIDATOR]) {
+            Some(FdwRoutineClause::NoFunction)
+        } else {
+            None
+        };
+
+        let options = if self.parse_keyword(Keyword::OPTIONS) {
+            self.expect_token(&Token::LParen)?;
+            let opts = self.parse_comma_separated(|p| {
+                let key = p.parse_identifier()?;
+                let value = p.parse_identifier()?;
+                Ok(CreateServerOption { key, value })
+            })?;
+            self.expect_token(&Token::RParen)?;
+            Some(opts)
+        } else {
+            None
+        };
+
+        Ok(CreateForeignDataWrapper {
+            name,
+            handler,
+            validator,
+            options,
+        })
+    }
+
+    /// Parse a `CREATE FOREIGN TABLE` statement.
+    ///
+    /// See <https://www.postgresql.org/docs/current/sql-createforeigntable.html>
+    pub fn parse_create_foreign_table(
+        &mut self,
+    ) -> Result<CreateForeignTable, ParserError> {
+        let if_not_exists =
+            self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
+        let name = self.parse_object_name(false)?;
+        let (columns, _constraints) = self.parse_columns()?;
+        self.expect_keyword_is(Keyword::SERVER)?;
+        let server_name = self.parse_identifier()?;
+
+        let options = if self.parse_keyword(Keyword::OPTIONS) {
+            self.expect_token(&Token::LParen)?;
+            let opts = self.parse_comma_separated(|p| {
+                let key = p.parse_identifier()?;
+                let value = p.parse_identifier()?;
+                Ok(CreateServerOption { key, value })
+            })?;
+            self.expect_token(&Token::RParen)?;
+            Some(opts)
+        } else {
+            None
+        };
+
+        Ok(CreateForeignTable {
+            name,
+            if_not_exists,
+            columns,
+            server_name,
+            options,
+        })
+    }
+
     /// The index of the first unprocessed token.
     pub fn index(&self) -> usize {
         self.index

tests/sqlparser_postgres.rs

@@ -9460,6 +9460,102 @@ fn parse_lock_table() {
     }
 }
 
+#[test]
+fn parse_create_foreign_data_wrapper() {
+    // Minimal: name only.
+    let sql = "CREATE FOREIGN DATA WRAPPER myfdw";
+    let Statement::CreateForeignDataWrapper(stmt) = pg().verified_stmt(sql) else {
+        unreachable!()
+    };
+    assert_eq!(stmt.name.value, "myfdw");
+    assert!(stmt.handler.is_none());
+    assert!(stmt.validator.is_none());
+    assert!(stmt.options.is_none());
+
+    // With HANDLER.
+    let sql = "CREATE FOREIGN DATA WRAPPER myfdw HANDLER myhandler";
+    let Statement::CreateForeignDataWrapper(stmt) = pg().verified_stmt(sql) else {
+        unreachable!()
+    };
+    assert_eq!(
+        stmt.handler,
+        Some(FdwRoutineClause::Function(ObjectName::from(vec![
+            "myhandler".into()
+        ])))
+    );
+
+    // With NO HANDLER.
+    let sql = "CREATE FOREIGN DATA WRAPPER myfdw NO HANDLER";
+    let Statement::CreateForeignDataWrapper(stmt) = pg().verified_stmt(sql) else {
+        unreachable!()
+    };
+    assert_eq!(stmt.handler, Some(FdwRoutineClause::NoFunction));
+
+    // With NO VALIDATOR.
+    let sql = "CREATE FOREIGN DATA WRAPPER myfdw NO VALIDATOR";
+    let Statement::CreateForeignDataWrapper(stmt) = pg().verified_stmt(sql) else {
+        unreachable!()
+    };
+    assert_eq!(stmt.validator, Some(FdwRoutineClause::NoFunction));
+
+    // With HANDLER, VALIDATOR, and OPTIONS.
+    let sql = "CREATE FOREIGN DATA WRAPPER myfdw HANDLER myhandler VALIDATOR myvalidator OPTIONS (debug 'true')";
+    let Statement::CreateForeignDataWrapper(stmt) = pg().verified_stmt(sql) else {
+        unreachable!()
+    };
+    assert_eq!(
+        stmt.handler,
+        Some(FdwRoutineClause::Function(ObjectName::from(vec![
+            "myhandler".into()
+        ])))
+    );
+    assert_eq!(
+        stmt.validator,
+        Some(FdwRoutineClause::Function(ObjectName::from(vec![
+            "myvalidator".into()
+        ])))
+    );
+    let options = stmt.options.unwrap();
+    assert_eq!(options.len(), 1);
+    assert_eq!(options[0].key.value, "debug");
+    assert_eq!(options[0].value.value, "true");
+}
+
+#[test]
+fn parse_create_foreign_table() {
+    // Basic: columns and SERVER.
+    let sql = "CREATE FOREIGN TABLE ft1 (id INTEGER, name TEXT) SERVER myserver";
+    let Statement::CreateForeignTable(stmt) = pg().verified_stmt(sql) else {
+        unreachable!()
+    };
+    assert_eq!(stmt.name.to_string(), "ft1");
+    assert!(!stmt.if_not_exists);
+    assert_eq!(stmt.columns.len(), 2);
+    assert_eq!(stmt.columns[0].name.value, "id");
+    assert_eq!(stmt.columns[1].name.value, "name");
+    assert_eq!(stmt.server_name.value, "myserver");
+    assert!(stmt.options.is_none());
+
+    // With IF NOT EXISTS.
+    let sql = "CREATE FOREIGN TABLE IF NOT EXISTS ft2 (col INTEGER) SERVER remoteserver";
+    let Statement::CreateForeignTable(stmt) = pg().verified_stmt(sql) else {
+        unreachable!()
+    };
+    assert!(stmt.if_not_exists);
+    assert_eq!(stmt.name.to_string(), "ft2");
+
+    // With table-level OPTIONS.
+    let sql =
+        "CREATE FOREIGN TABLE ft3 (col INTEGER) SERVER remoteserver OPTIONS (schema_name 'public')";
+    let Statement::CreateForeignTable(stmt) = pg().verified_stmt(sql) else {
+        unreachable!()
+    };
+    let options = stmt.options.unwrap();
+    assert_eq!(options.len(), 1);
+    assert_eq!(options[0].key.value, "schema_name");
+    assert_eq!(options[0].value.value, "public");
+}
+
 #[test]
 fn parse_create_aggregate_basic() {
     let sql = "CREATE AGGREGATE myavg (NUMERIC) (SFUNC = numeric_avg_accum, STYPE = internal, FINALFUNC = numeric_avg, INITCOND = '0')";