feat(postgres): parse CREATE TYPE statements

sqlglot/dialects/postgres.py

@@ -98,6 +98,7 @@ class Tokenizer(tokens.Tokenizer):
             "SERIAL": TokenType.SERIAL,
             "SMALLSERIAL": TokenType.SMALLSERIAL,
             "TEMP": TokenType.TEMPORARY,
+            "TYPE": TokenType.TYPE,
             "REGCLASS": TokenType.OBJECT_IDENTIFIER,
             "REGCOLLATION": TokenType.OBJECT_IDENTIFIER,
             "REGCONFIG": TokenType.OBJECT_IDENTIFIER,

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):
+            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/parser.py

@@ -644,6 +644,7 @@ class Parser:
         TokenType.INDEX,
         TokenType.PROCEDURE,
         TokenType.TRIGGER,
+        TokenType.TYPE,
         *DB_CREATABLES,
     }
 
@@ -754,6 +755,7 @@ class Parser:
         TokenType.UNPIVOT,
         TokenType.UPDATE,
         TokenType.USE,
+        TokenType.TYPE,
         TokenType.VOLATILE,
         TokenType.WINDOW,
         TokenType.CURRENT_CATALOG,
@@ -2485,6 +2487,20 @@ def extend_props(temp_props: exp.Properties | None) -> None:
 
             this = trigger_name
             extend_props(exp.Properties(expressions=[trigger_props] if trigger_props else []))
+        elif create_token_type == TokenType.TYPE:
+            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):
+                expression = exp.DataType(
+                    this=exp.DType.ENUM,
+                    expressions=self._parse_wrapped_csv(self._parse_string),
+                )
+            elif self._match(TokenType.L_PAREN, advance=False):
+                expression = self._parse_schema()
+            else:
+                return self._parse_as_command(start)
         elif create_token_type in self.DB_CREATABLES:
             table_parts = self._parse_table_parts(
                 schema=True, is_db_reference=create_token_type == TokenType.SCHEMA

sqlglot/tokenizer_core.py

@@ -427,6 +427,7 @@ class TokenType(IntEnum):
     TRUE = auto()
     TRUNCATE = auto()
     TRIGGER = auto()
+    TYPE = auto()
     UNCACHE = auto()
     UNION = auto()
     UNNEST = auto()

tests/dialects/test_postgres.py

@@ -1076,6 +1076,28 @@ def test_ddl(self):
             exp.DataType
         )
 
+        create_type = self.validate_identity(
+            "CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy')"
+        ).assert_is(exp.Create)
+        self.assertTrue(create_type.expression.assert_is(exp.DataType).is_type(exp.DType.ENUM))
+
+        self.validate_identity("CREATE TYPE mood AS ENUM ()").assert_is(exp.Create)
+
+        create_type = self.validate_identity(
+            "CREATE TYPE inventory_item AS (name TEXT, supplier_id INT, price DECIMAL)"
+        ).assert_is(exp.Create)
+        create_type.expression.assert_is(exp.Schema)
+
+        self.validate_identity("CREATE TYPE public.mood AS ENUM ('sad', 'ok')").assert_is(
+            exp.Create
+        )
+
+        self.validate_identity("CREATE TYPE widget", check_command_warning=True)
+        self.validate_identity(
+            "CREATE TYPE float8range AS RANGE (subtype = float8, subtype_diff = float8mi)",
+            check_command_warning=True,
+        )
+
         # 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