Refactored introducing struct CreateDomain

Author: LucaCappelletti94

src/ast/ddl.rs

@@ -2153,6 +2153,50 @@ impl fmt::Display for ClusteredBy {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+/// ```sql
+/// CREATE DOMAIN name [ AS ] data_type
+///         [ COLLATE collation ]
+///         [ DEFAULT expression ]
+///         [ domain_constraint [ ... ] ]
+///
+///     where domain_constraint is:
+///
+///     [ CONSTRAINT constraint_name ]
+///     { NOT NULL | NULL | CHECK (expression) }
+/// ```
+/// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createdomain.html)
+pub struct CreateDomain {
+    /// The name of the domain to be created.
+    name: ObjectName,
+    /// The data type of the domain.
+    data_type: DataType,
+    /// The collation of the domain.
+    collation: Option<Ident>,
+    /// The default value of the domain.
+    default: Option<Expr>,
+    /// The constraints of the domain.
+    constraints: Vec<TableConstraint>,
+}
+
+impl fmt::Display for CreateDomain {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CREATE DOMAIN {name} AS {data_type}")?;
+        if let Some(collation) = collation {
+            write!(f, " COLLATE {collation}")?;
+        }
+        if let Some(default) = default {
+            write!(f, " DEFAULT {default}")?;
+        }
+        if !constraints.is_empty() {
+            write!(f, " {}", display_separated(constraints, " "))?;
+        }
+        Ok(())
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

src/ast/mod.rs

@@ -3979,13 +3979,7 @@ pub enum Statement {
     ///     { NOT NULL | NULL | CHECK (expression) }
     /// ```
     /// See [PostgreSQL](https://www.postgresql.org/docs/current/sql-createdomain.html)
-    CreateDomain {
-        name: ObjectName,
-        data_type: DataType,
-        collation: Option<Ident>,
-        default: Option<Expr>,
-        constraints: Vec<TableConstraint>,
-    },
+    CreateDomain(CreateDomain),
     /// ```sql
     /// CREATE TYPE <name>
     /// ```
@@ -4532,25 +4526,7 @@ impl fmt::Display for Statement {
                 Ok(())
             }
             Statement::CreateFunction(create_function) => create_function.fmt(f),
-            Statement::CreateDomain {
-                name,
-                data_type,
-                collation,
-                default,
-                constraints,
-            } => {
-                write!(f, "CREATE DOMAIN {name} AS {data_type}")?;
-                if let Some(collation) = collation {
-                    write!(f, " COLLATE {collation}")?;
-                }
-                if let Some(default) = default {
-                    write!(f, " DEFAULT {default}")?;
-                }
-                if !constraints.is_empty() {
-                    write!(f, " {}", display_separated(constraints, " "))?;
-                }
-                Ok(())
-            }
+            Statement::CreateDomain(create_domain) => create_domain.fmt(f),
             Statement::CreateTrigger {
                 or_replace,
                 is_constraint,

src/parser/mod.rs

@@ -5928,13 +5928,13 @@ impl<'a> Parser<'a> {
             constraints.push(constraint);
         }
 
-        Ok(Statement::CreateDomain {
+        Ok(Statement::CreateDomain(CreateDomain {
             name,
             data_type,
             collation,
             default,
             constraints,
-        })
+        }))
     }
 
     /// ```sql

tests/sqlparser_postgres.rs

@@ -5083,7 +5083,7 @@ fn test_escaped_string_literal() {
 #[test]
 fn parse_create_domain() {
     let sql1 = "CREATE DOMAIN my_domain AS INTEGER CHECK (VALUE > 0)";
-    let expected = Statement::CreateDomain {
+    let expected = Statement::CreateDomain(CreateDomain {
         name: ObjectName::from(vec![Ident::new("my_domain")]),
         data_type: DataType::Integer(None),
         collation: None,
@@ -5096,15 +5096,15 @@ fn parse_create_domain() {
                 right: Box::new(Expr::Value(test_utils::number("0").into())),
             }),
         }],
-    };
+    });
 
     assert_eq!(pg().verified_stmt(sql1), expected);
 }
 
 #[test]
 fn parse_create_domain_with_collation() {
     let sql2 = "CREATE DOMAIN my_domain AS INTEGER COLLATE \"en_US\" CHECK (VALUE > 0)";
-    let expected = Statement::CreateDomain {
+    let expected = Statement::CreateDomain(CreateDomain {
         name: ObjectName::from(vec![Ident::new("my_domain")]),
         data_type: DataType::Integer(None),
         collation: Some(Ident::with_quote('"', "en_US")),
@@ -5117,15 +5117,15 @@ fn parse_create_domain_with_collation() {
                 right: Box::new(Expr::Value(test_utils::number("0").into())),
             }),
         }],
-    };
+    });
 
     assert_eq!(pg().verified_stmt(sql2), expected);
 }
 
 #[test]
 fn parse_create_domain_with_default() {
     let sql3 = "CREATE DOMAIN my_domain AS INTEGER DEFAULT 1 CHECK (VALUE > 0)";
-    let expected = Statement::CreateDomain {
+    let expected = Statement::CreateDomain(CreateDomain {
         name: ObjectName::from(vec![Ident::new("my_domain")]),
         data_type: DataType::Integer(None),
         collation: None,
@@ -5138,15 +5138,15 @@ fn parse_create_domain_with_default() {
                 right: Box::new(Expr::Value(test_utils::number("0").into())),
             }),
         }],
-    };
+    });
 
     assert_eq!(pg().verified_stmt(sql3), expected);
 }
 
 #[test]
 fn parse_create_domain_with_default_and_collation() {
     let sql4 = "CREATE DOMAIN my_domain AS INTEGER COLLATE \"en_US\" DEFAULT 1 CHECK (VALUE > 0)";
-    let expected = Statement::CreateDomain {
+    let expected = Statement::CreateDomain(CreateDomain {
         name: ObjectName::from(vec![Ident::new("my_domain")]),
         data_type: DataType::Integer(None),
         collation: Some(Ident::with_quote('"', "en_US")),
@@ -5159,15 +5159,15 @@ fn parse_create_domain_with_default_and_collation() {
                 right: Box::new(Expr::Value(test_utils::number("0").into())),
             }),
         }],
-    };
+    });
 
     assert_eq!(pg().verified_stmt(sql4), expected);
 }
 
 #[test]
 fn parse_create_domain_with_named_constraint() {
     let sql5 = "CREATE DOMAIN my_domain AS INTEGER CONSTRAINT my_constraint CHECK (VALUE > 0)";
-    let expected = Statement::CreateDomain {
+    let expected = Statement::CreateDomain(CreateDomain {
         name: ObjectName::from(vec![Ident::new("my_domain")]),
         data_type: DataType::Integer(None),
         collation: None,
@@ -5180,7 +5180,7 @@ fn parse_create_domain_with_named_constraint() {
                 right: Box::new(Expr::Value(test_utils::number("0").into())),
             }),
         }],
-    };
+    });
 
     assert_eq!(pg().verified_stmt(sql5), expected);
 }