Upgrade types formatting to new CST structure

Author: nene

src/node_utils.ts

@@ -26,3 +26,4 @@ export const isListExpr = is("list_expr");
 export const isCreateFunctionStmt = is("create_function_stmt");
 export const isLanguageClause = is("language_clause");
 export const isDynamicallyLoadedFunction = is("dynamically_loaded_function");
+export const isDataTypeName = is("data_type_name");

src/syntax/base.ts

@@ -1,15 +1,9 @@
 import { AllColumns, Empty, Keyword, Node } from "sql-parser-cst";
 import { CstToDocMap } from "../CstToDocMap";
-import { AstPath } from "prettier";
 
 export const baseMap: CstToDocMap<Keyword | Empty | AllColumns> = {
   /** cst-ignore: name */
   keyword: (print, node, path, options) => {
-    // Treat PostgreSQL "WITH TIME ZONE" as part of data type, not keyword,
-    // so skip keyword case conversion for it
-    if ((path as AstPath<Node>).parent?.type === "with_time_zone_data_type") {
-      return path.node.text;
-    }
     switch (options.sqlKeywordCase) {
       case "preserve":
         return path.node.text;

src/syntax/data_type.ts

@@ -1,18 +1,31 @@
-import { AllDataTypeNodes, NamedDataType } from "sql-parser-cst";
+import { AllDataTypeNodes, DataType } from "sql-parser-cst";
 import { isArray } from "../utils";
 import { CstToDocMap } from "../CstToDocMap";
-import { group, indent, softline } from "../print_utils";
+import { group, indent, join, softline } from "../print_utils";
+import { isDataTypeName } from "../node_utils";
 
 export const dataTypeMap: CstToDocMap<AllDataTypeNodes> = {
+  data_type_name: (print) => print.spaced("name"),
   // print single-word types as `TYPE(10)` and multi-word types as `MY TYPE (10)`
-  named_data_type: (print, node) =>
-    (isMultiWordTypeName(node) ? print.spaced : print)(["name", "params"]),
-  data_type_identifier: (print) => print.spaced("name"),
+  modified_data_type: (print, node) =>
+    (isMultiWordTypeName(node.dataType) ? print.spaced : print)([
+      "dataType",
+      "modifiers",
+    ]),
+
   setof_data_type: (print) => print.spaced(["setofKw", "dataType"]),
   array_data_type: (print) => print(["dataType", "bounds"]),
   array_bounds: (print) => ["[", print("bounds"), "]"],
-  with_time_zone_data_type: (print) =>
-    print.spaced(["dataType", "withTimeZoneKw"]),
+  time_data_type: (print, node) =>
+    group(
+      join(" ", [
+        print(["timeKw", "precision"]),
+        ...(node.timeZoneKw ? [print.spaced("timeZoneKw")] : []),
+      ]),
+    ),
+  interval_data_type: (print) =>
+    print.spaced(["intervalKw", "fieldsKw", "precision"]),
+  parametric_data_type: (print) => print(["typeKw", "params"]),
   generic_type_params: (print) =>
     group(["<", indent([softline, print("params")]), softline, ">"]),
   array_type_param: (print) => print.spaced(["dataType", "constraints"]),
@@ -21,9 +34,6 @@ export const dataTypeMap: CstToDocMap<AllDataTypeNodes> = {
   table_data_type: (print) => print.spaced(["tableKw", "columns"]),
 };
 
-function isMultiWordTypeName(node: NamedDataType): boolean {
-  return (
-    isArray(node.name) ||
-    (node.name.type === "data_type_identifier" && isArray(node.name.name))
-  );
+function isMultiWordTypeName(node: DataType): boolean {
+  return isDataTypeName(node) && isArray(node.name) && node.name.length > 1;
 }

test/ddl/create_table.test.ts

@@ -316,7 +316,7 @@ describe("create table", () => {
     `);
   });
 
-  it(`formats TIME ZONE modifier on TIME data types`, async () => {
+  it(`formats TIME/TIMESTAMP data types`, async () => {
     await testPostgresql(dedent`
       CREATE TABLE client (
         from_date TIME WITH TIME ZONE,
@@ -325,6 +325,14 @@ describe("create table", () => {
     `);
   });
 
+  it(`formats INTERVAL data types`, async () => {
+    await testPostgresql(dedent`
+      CREATE TABLE client (
+        foo INTERVAL DAY TO SECOND (2)
+      )
+    `);
+  });
+
   it(`formats SQLite table options`, async () => {
     await test(dedent`
       CREATE TABLE foo (

test/options/keywordCase.test.ts

@@ -61,13 +61,14 @@ describe("sqlKeywordCase option", () => {
     },
   );
 
-  it(`sqlKeywordCase: "upper" does not effect PostgreSQL data types`, async () => {
+  it(`sqlKeywordCase: "upper" effects PostgreSQL builtin data types`, async () => {
     expect(
       await pretty(
         `CREATE TABLE foo (
         col1 int, col2 character varying (255),
         col3 my_schema.custom_type,
-        col4 timestamp with time zone
+        col4 timestamp with time zone,
+        col5 uuid
         )`,
         {
           dialect: "postgresql",
@@ -76,10 +77,11 @@ describe("sqlKeywordCase option", () => {
       ),
     ).toBe(dedent`
       CREATE TABLE foo (
-        col1 int,
-        col2 character varying (255),
+        col1 INT,
+        col2 CHARACTER VARYING (255),
         col3 my_schema.custom_type,
-        col4 timestamp with time zone
+        col4 TIMESTAMP WITH TIME ZONE,
+        col5 uuid
       )
     `);
   });