Merge branch 'sqlLiteralCase-option'

Refs #13

Author: nene

README.md

@@ -121,7 +121,8 @@ There are also some SQL-specific options:
 
 | API Option                    | Default | Description                                                                                                                                                                                                                     |
 | ----------------------------- | :-----: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `sqlKeywordCase`              | `upper` | Converts SQL keywords to `upper` or `lower` case, or `preserve` existing. Note that for now `preserve` is somewhat incompatible with `sqlCanonicalSyntax: true` (e.g. the added `AS` keywords will always be in uppercase).     |
+| `sqlKeywordCase`              | `upper` | Convert SQL keywords to `upper` or `lower` case, or `preserve` existing. Note that for now `preserve` is somewhat incompatible with `sqlCanonicalSyntax: true` (e.g. the added `AS` keywords will always be in uppercase).      |
+| `sqlLiteralCase`              | `upper` | Convert SQL literals TRUE, FALSE and NULL to `upper` or `lower` case, or `preserve` existing.                                                                                                                                   |
 | `sqlParamTypes`               |  `[]`   | Array of bound parameter types: `?`, `?nr`, `$nr`, `:name`, `@name`, `$name`.                                                                                                                                                   |
 | `sqlCanonicalSyntax`          | `true`  | When enabled, performs some opinionated changes of keywords and operators, like enforcing the use of `AS` in aliases and replacing `<>` comparisons with `!=`. See [STYLE_GUIDE][] for more details. (Since 0.11.0)             |
 | `sqlFinalSemicolon`           | `true`  | When enabled, enforces a semicolon at the end of last statement. When disabled leaves it up to the author whether to add a final semicolon or not. (Since 0.13.0)                                                               |

src/options.ts

@@ -3,6 +3,7 @@ import { Node, ParserOptions as CstParserOptions } from "sql-parser-cst";
 
 export interface SqlPluginOptions {
   sqlKeywordCase: "preserve" | "upper" | "lower";
+  sqlLiteralCase: "preserve" | "upper" | "lower";
   sqlParamTypes: NonNullable<CstParserOptions["paramTypes"]>;
   sqlCanonicalSyntax: boolean;
   sqlFinalSemicolon: boolean;
@@ -36,6 +37,30 @@ export const options: SupportOptions = {
       },
     ],
   },
+  sqlLiteralCase: {
+    type: "choice",
+    category: "SQL",
+    default: "upper",
+    description:
+      "Enforces upper/lower case for SQL literals (TRUE, FALSE, NULL)",
+    choices: [
+      {
+        value: "preserve",
+        description: "preserves the existing case",
+        since: "0.14.0",
+      },
+      {
+        value: "upper",
+        description: "forces all keywords to uppercase",
+        since: "0.14.0",
+      },
+      {
+        value: "lower",
+        description: "forces all keywords to lowercase",
+        since: "0.14.0",
+      },
+    ],
+  },
   sqlParamTypes: {
     type: "string",
     array: true,

src/syntax/expr.ts

@@ -23,6 +23,7 @@ import {
   isCompoundSelectStmt,
 } from "../node_utils";
 import { isString, last } from "../utils";
+import { AllPrettierOptions } from "src/options";
 
 export const exprMap: CstToDocMap<AllExprNodes> = {
   list_expr: (print, node, path) => {
@@ -169,13 +170,15 @@ export const exprMap: CstToDocMap<AllExprNodes> = {
   /** cst-ignore: value */
   number_literal: (print) => print("text"),
   /** cst-ignore: value */
-  boolean_literal: (print) => print("valueKw"),
+  boolean_literal: (print, node, path, options) =>
+    printLiteral(node.valueKw, options),
   /** cst-ignore: value */
   string_literal: (print) => print("text"),
   /** cst-ignore: value */
   blob_literal: (print) => print("text"),
   /** cst-ignore: value */
-  null_literal: (print) => print("nullKw"),
+  null_literal: (print, node, path, options) =>
+    printLiteral(node.nullKw, options),
   numeric_literal: (print) => print.spaced(["numericKw", "string"]),
   bignumeric_literal: (print) => print.spaced(["bignumericKw", "string"]),
   date_literal: (print) => print.spaced(["dateKw", "string"]),
@@ -191,4 +194,15 @@ export const exprMap: CstToDocMap<AllExprNodes> = {
   parameter: (print) => print("text"),
 };
 
+const printLiteral = <T>(node: Keyword, options: AllPrettierOptions<T>) => {
+  switch (options.sqlLiteralCase) {
+    case "preserve":
+      return node.text;
+    case "upper":
+      return node.text.toUpperCase();
+    case "lower":
+      return node.text.toLowerCase();
+  }
+};
+
 const isBooleanOp = ({ name }: Keyword) => name === "AND" || name === "OR";

test/options/literalCase.test.ts

@@ -0,0 +1,40 @@
+import dedent from "dedent-js";
+import { pretty } from "../test_utils";
+
+describe("sqlLiteralCase option", () => {
+  it(`defaults to uppercasing of all literals`, async () => {
+    expect(await pretty(`SELECT true, false, null`)).toBe(dedent`
+      SELECT TRUE, FALSE, NULL
+    `);
+  });
+
+  it(`sqlKeywordCase: "preserve" keeps keywords case as-is`, async () => {
+    expect(
+      await pretty(`SELECT true, False, NULL`, {
+        sqlLiteralCase: "preserve",
+      }),
+    ).toBe(dedent`
+      SELECT true, False, NULL
+    `);
+  });
+
+  it(`sqlLiteralCase: "upper" converts keywords to uppercase`, async () => {
+    expect(
+      await pretty(`SELECT true, False, NULL`, {
+        sqlLiteralCase: "upper",
+      }),
+    ).toBe(dedent`
+      SELECT TRUE, FALSE, NULL
+    `);
+  });
+
+  it(`sqlLiteralCase: "lower" converts keywords to lowercase`, async () => {
+    expect(
+      await pretty(`SELECT true, False, NULL`, {
+        sqlLiteralCase: "lower",
+      }),
+    ).toBe(dedent`
+      SELECT true, false, null
+    `);
+  });
+});