feat(postgres): parse CREATE TYPE statements

sqlglot/generators/postgres.py

@@ -481,6 +481,9 @@ def datatype_sql(self, expression: exp.DataType) -> str:
                 return f"{self.expressions(expression, flat=True)}[{values}]"
             return "ARRAY"
 
+        if expression.is_type(exp.DType.ENUM) and expression.expressions:
+            return f"ENUM ({self.expressions(expression, flat=True)})"
+
         if expression.is_type(exp.DType.DOUBLE, exp.DType.FLOAT) and expression.expressions:
             # Postgres doesn't support precision for REAL and DOUBLE PRECISION types
             return f"FLOAT({self.expressions(expression, flat=True)})"

sqlglot/parsers/postgres.py

@@ -202,6 +202,26 @@ class PostgresParser(parser.Parser):
 
     ARG_MODE_TOKENS: t.ClassVar = {TokenType.IN, TokenType.OUT, TokenType.INOUT, TokenType.VARIADIC}
 
+    def _parse_create(self) -> exp.Create | exp.Command:
+        start = self._prev
+
+        if not self._match_text_seq("TYPE"):
+            return super()._parse_create()
+
+        this = self._parse_table_parts(schema=True)
+        if not this or not self._match(TokenType.ALIAS):
+            return self._parse_as_command(start)
+
+        if self._match(TokenType.ENUM, advance=False):
+            expression = self._parse_types()
+        else:
+            expression = self._parse_schema()
+
+        if not expression or self._curr:
+            return self._parse_as_command(start)
+
+        return self.expression(exp.Create(this=this, kind="TYPE", expression=expression))
+
     def _parse_parameter_mode(self) -> TokenType | None:
         """
         Parse PostgreSQL function parameter mode (IN, OUT, INOUT, VARIADIC).

tests/dialects/test_postgres.py

@@ -1076,6 +1076,39 @@ def test_ddl(self):
             exp.DataType
         )
 
+        create_type = self.parse_one("CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy')")
+        self.assertIsInstance(create_type, exp.Create)
+        self.assertEqual(create_type.kind, "TYPE")
+        self.assertEqual(create_type.this, exp.to_table("mood"))
+
+        enum_type = create_type.expression
+        self.assertIsInstance(enum_type, exp.DataType)
+        self.assertTrue(enum_type.is_type(exp.DType.ENUM))
+        self.assertEqual([value.name for value in enum_type.expressions], ["sad", "ok", "happy"])
+        self.validate_identity("CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy')")
+
+        create_type = self.parse_one(
+            "CREATE TYPE inventory_item AS (name TEXT, supplier_id INT, price DECIMAL)"
+        )
+        self.assertIsInstance(create_type, exp.Create)
+        self.assertEqual(create_type.kind, "TYPE")
+
+        composite_type = create_type.expression
+        self.assertIsInstance(composite_type, exp.Schema)
+        columns = composite_type.expressions
+        self.assertEqual([column.this.name for column in columns], ["name", "supplier_id", "price"])
+        self.assertEqual(
+            [column.kind.this for column in columns],
+            [exp.DType.TEXT, exp.DType.INT, exp.DType.DECIMAL],
+        )
+        self.validate_identity(
+            "CREATE TYPE inventory_item AS (name TEXT, supplier_id INT, price DECIMAL)"
+        )
+
+        create_type = self.parse_one("CREATE TYPE public.mood AS ENUM ('sad', 'ok')")
+        self.assertEqual(create_type.this.sql(dialect="postgres"), "public.mood")
+        self.validate_identity("CREATE TYPE public.mood AS ENUM ('sad', 'ok')")
+
         # Checks that OID is parsed into a DataType (ObjectIdentifier)
         self.assertIsInstance(
             self.parse_one("CREATE TABLE p.t (c oid)").find(exp.DataType), exp.ObjectIdentifier