Add support for CREATE TYPE (AS) statements

Author: srijs

src/ast/ddl.rs

@@ -715,3 +715,23 @@ impl fmt::Display for ReferentialAction {
         })
     }
 }
+
+/// SQL composite type attribute definition
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateTypeAttrDef {
+    pub name: Ident,
+    pub data_type: DataType,
+    pub collation: Option<ObjectName>,
+}
+
+impl fmt::Display for CreateTypeAttrDef {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} {}", self.name, self.data_type)?;
+        if let Some(collation) = &self.collation {
+            write!(f, " COLLATE {collation}")?;
+        }
+        Ok(())
+    }
+}

src/ast/mod.rs

@@ -30,7 +30,8 @@ pub use self::data_type::{
 };
 pub use self::ddl::{
     AlterColumnOperation, AlterIndexOperation, AlterTableOperation, ColumnDef, ColumnOption,
-    ColumnOptionDef, GeneratedAs, IndexType, KeyOrIndexDisplay, ReferentialAction, TableConstraint,
+    ColumnOptionDef, CreateTypeAttrDef, GeneratedAs, IndexType, KeyOrIndexDisplay,
+    ReferentialAction, TableConstraint,
 };
 pub use self::operator::{BinaryOperator, UnaryOperator};
 pub use self::query::{
@@ -1711,6 +1712,11 @@ pub enum Statement {
         sequence_options: Vec<SequenceOptions>,
         owned_by: Option<ObjectName>,
     },
+    /// CREATE TYPE <name>
+    CreateType {
+        name: ObjectName,
+        attributes: Vec<CreateTypeAttrDef>,
+    },
 }
 
 impl fmt::Display for Statement {
@@ -2921,6 +2927,13 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
+            Statement::CreateType { name, attributes } => {
+                write!(
+                    f,
+                    "CREATE TYPE {name} AS ({})",
+                    display_comma_separated(attributes)
+                )
+            }
         }
     }
 }

src/parser.rs

@@ -2365,6 +2365,8 @@ impl<'a> Parser<'a> {
             self.parse_create_role()
         } else if self.parse_keyword(Keyword::SEQUENCE) {
             self.parse_create_sequence(temporary)
+        } else if self.parse_keyword(Keyword::TYPE) {
+            self.parse_create_type()
         } else {
             self.expected("an object type after CREATE", self.peek_token())
         }
@@ -7053,6 +7055,40 @@ impl<'a> Parser<'a> {
             window_frame,
         })
     }
+
+    pub fn parse_create_type(&mut self) -> Result<Statement, ParserError> {
+        let name = self.parse_object_name()?;
+        self.expect_keyword(Keyword::AS)?;
+
+        let mut attributes = vec![];
+        if !self.consume_token(&Token::LParen) || self.consume_token(&Token::RParen) {
+            return Ok(Statement::CreateType { name, attributes });
+        }
+
+        loop {
+            let attr_name = self.parse_identifier()?;
+            let attr_data_type = self.parse_data_type()?;
+            let attr_collation = if self.parse_keyword(Keyword::COLLATE) {
+                Some(self.parse_object_name()?)
+            } else {
+                None
+            };
+            attributes.push(CreateTypeAttrDef {
+                name: attr_name,
+                data_type: attr_data_type,
+                collation: attr_collation,
+            });
+            let comma = self.consume_token(&Token::Comma);
+            if self.consume_token(&Token::RParen) {
+                // allow a trailing comma
+                break;
+            } else if !comma {
+                return self.expected("',' or ')' after attribute definition", self.peek_token());
+            }
+        }
+
+        Ok(Statement::CreateType { name, attributes })
+    }
 }
 
 impl Word {

tests/sqlparser_postgres.rs

@@ -2972,3 +2972,27 @@ fn parse_truncate() {
         truncate
     );
 }
+
+#[test]
+fn parse_create_type() {
+    let create_type = pg_and_generic()
+        .verified_stmt("CREATE TYPE db.type_name AS (foo INT, bar TEXT COLLATE \"de_DE\")");
+    assert_eq!(
+        Statement::CreateType {
+            name: ObjectName(vec![Ident::new("db"), Ident::new("type_name")]),
+            attributes: vec![
+                CreateTypeAttrDef {
+                    name: Ident::new("foo"),
+                    data_type: DataType::Int(None),
+                    collation: None,
+                },
+                CreateTypeAttrDef {
+                    name: Ident::new("bar"),
+                    data_type: DataType::Text,
+                    collation: Some(ObjectName(vec![Ident::with_quote('\"', "de_DE")])),
+                }
+            ]
+        },
+        create_type
+    );
+}