sql-typechecker 0.0.1

package/src/builtinunaryoperators.ts

@@ -0,0 +1,291 @@
+import { unaryOp } from "./typecheck";
+
+const builtinunaryoperatorsFromSyntax: unaryOp[] = [
+  // {
+  //   name: { name: "IS NULL" },
+  //   operand: { kind: "nullable", typevar: { kind: "anyscalar" } },
+  //   result: { kind: "scalar", name: { name: "boolean" } },
+  //   description: "is NULL check",
+  // },
+];
+
+const builtinunaryoperatorsFromSchema: unaryOp[] = [
+  {
+    name: { name: "!" },
+    operand: { kind: "scalar", name: { name: "bigint" } },
+    result: { kind: "scalar", name: { name: "numeric" } },
+    description: "factorial",
+  },
+  {
+    name: { name: "!!" },
+    operand: { kind: "scalar", name: { name: "bigint" } },
+    result: { kind: "scalar", name: { name: "numeric" } },
+    description: "deprecated, use ! instead",
+  },
+  {
+    name: { name: "!!" },
+    operand: { kind: "scalar", name: { name: "tsquery" } },
+    result: { kind: "scalar", name: { name: "tsquery" } },
+    description: "NOT tsquery",
+  },
+  {
+    name: { name: "#" },
+    operand: { kind: "scalar", name: { name: "path" } },
+    result: { kind: "scalar", name: { name: "integer" } },
+    description: "number of points",
+  },
+  {
+    name: { name: "#" },
+    operand: { kind: "scalar", name: { name: "polygon" } },
+    result: { kind: "scalar", name: { name: "integer" } },
+    description: "number of points",
+  },
+
+  {
+    name: { name: "+" },
+    operand: { kind: "scalar", name: { name: "bigint" } },
+    result: { kind: "scalar", name: { name: "bigint" } },
+    description: "unary plus",
+  },
+  {
+    name: { name: "+" },
+    operand: { kind: "scalar", name: { name: "double precision" } },
+    result: { kind: "scalar", name: { name: "double precision" } },
+    description: "unary plus",
+  },
+  {
+    name: { name: "+" },
+    operand: { kind: "scalar", name: { name: "integer" } },
+    result: { kind: "scalar", name: { name: "integer" } },
+    description: "unary plus",
+  },
+  {
+    name: { name: "+" },
+    operand: { kind: "scalar", name: { name: "numeric" } },
+    result: { kind: "scalar", name: { name: "numeric" } },
+    description: "unary plus",
+  },
+  {
+    name: { name: "+" },
+    operand: { kind: "scalar", name: { name: "real" } },
+    result: { kind: "scalar", name: { name: "real" } },
+    description: "unary plus",
+  },
+  {
+    name: { name: "+" },
+    operand: { kind: "scalar", name: { name: "smallint" } },
+    result: { kind: "scalar", name: { name: "smallint" } },
+    description: "unary plus",
+  },
+
+  {
+    name: { name: "-" },
+    operand: { kind: "scalar", name: { name: "bigint" } },
+    result: { kind: "scalar", name: { name: "bigint" } },
+    description: "negate",
+  },
+  {
+    name: { name: "-" },
+    operand: { kind: "scalar", name: { name: "double precision" } },
+    result: { kind: "scalar", name: { name: "double precision" } },
+    description: "negate",
+  },
+  {
+    name: { name: "-" },
+    operand: { kind: "scalar", name: { name: "integer" } },
+    result: { kind: "scalar", name: { name: "integer" } },
+    description: "negate",
+  },
+  {
+    name: { name: "-" },
+    operand: { kind: "scalar", name: { name: "interval" } },
+    result: { kind: "scalar", name: { name: "interval" } },
+    description: "negate",
+  },
+  {
+    name: { name: "-" },
+    operand: { kind: "scalar", name: { name: "numeric" } },
+    result: { kind: "scalar", name: { name: "numeric" } },
+    description: "negate",
+  },
+  {
+    name: { name: "-" },
+    operand: { kind: "scalar", name: { name: "real" } },
+    result: { kind: "scalar", name: { name: "real" } },
+    description: "negate",
+  },
+  {
+    name: { name: "-" },
+    operand: { kind: "scalar", name: { name: "smallint" } },
+    result: { kind: "scalar", name: { name: "smallint" } },
+    description: "negate",
+  },
+
+  {
+    name: { name: "?-" },
+    operand: { kind: "scalar", name: { name: "line" } },
+    result: { kind: "scalar", name: { name: "boolean" } },
+    description: "horizontal",
+  },
+  {
+    name: { name: "?-" },
+    operand: { kind: "scalar", name: { name: "lseg" } },
+    result: { kind: "scalar", name: { name: "boolean" } },
+    description: "horizontal",
+  },
+
+  {
+    name: { name: "?|" },
+    operand: { kind: "scalar", name: { name: "line" } },
+    result: { kind: "scalar", name: { name: "boolean" } },
+    description: "vertical",
+  },
+  {
+    name: { name: "?|" },
+    operand: { kind: "scalar", name: { name: "lseg" } },
+    result: { kind: "scalar", name: { name: "boolean" } },
+    description: "vertical",
+  },
+
+  {
+    name: { name: "@" },
+    operand: { kind: "scalar", name: { name: "bigint" } },
+    result: { kind: "scalar", name: { name: "bigint" } },
+    description: "absolute value",
+  },
+  {
+    name: { name: "@" },
+    operand: { kind: "scalar", name: { name: "double precision" } },
+    result: { kind: "scalar", name: { name: "double precision" } },
+    description: "absolute value",
+  },
+  {
+    name: { name: "@" },
+    operand: { kind: "scalar", name: { name: "integer" } },
+    result: { kind: "scalar", name: { name: "integer" } },
+    description: "absolute value",
+  },
+  {
+    name: { name: "@" },
+    operand: { kind: "scalar", name: { name: "numeric" } },
+    result: { kind: "scalar", name: { name: "numeric" } },
+    description: "absolute value",
+  },
+  {
+    name: { name: "@" },
+    operand: { kind: "scalar", name: { name: "real" } },
+    result: { kind: "scalar", name: { name: "real" } },
+    description: "absolute value",
+  },
+  {
+    name: { name: "@" },
+    operand: { kind: "scalar", name: { name: "smallint" } },
+    result: { kind: "scalar", name: { name: "smallint" } },
+    description: "absolute value",
+  },
+  {
+    name: { name: "@-@" },
+    operand: { kind: "scalar", name: { name: "lseg" } },
+    result: { kind: "scalar", name: { name: "double precision" } },
+    description: "distance between endpoints",
+  },
+  {
+    name: { name: "@-@" },
+    operand: { kind: "scalar", name: { name: "path" } },
+    result: { kind: "scalar", name: { name: "double precision" } },
+    description: "sum of path segment lengths",
+  },
+
+  {
+    name: { name: "@@" },
+    operand: { kind: "scalar", name: { name: "box" } },
+    result: { kind: "scalar", name: { name: "point" } },
+    description: "center of",
+  },
+  {
+    name: { name: "@@" },
+    operand: { kind: "scalar", name: { name: "circle" } },
+    result: { kind: "scalar", name: { name: "point" } },
+    description: "center of",
+  },
+  {
+    name: { name: "@@" },
+    operand: { kind: "scalar", name: { name: "lseg" } },
+    result: { kind: "scalar", name: { name: "point" } },
+    description: "center of",
+  },
+  {
+    name: { name: "@@" },
+    operand: { kind: "scalar", name: { name: "path" } },
+    result: { kind: "scalar", name: { name: "point" } },
+    description: "center of",
+  },
+  {
+    name: { name: "@@" },
+    operand: { kind: "scalar", name: { name: "polygon" } },
+    result: { kind: "scalar", name: { name: "point" } },
+    description: "center of",
+  },
+
+  {
+    name: { name: "|" },
+    operand: { kind: "scalar", name: { name: "tinterval" } },
+    result: { kind: "scalar", name: { name: "abstime" } },
+    description: "start of interval",
+  },
+
+  {
+    name: { name: "|/" },
+    operand: { kind: "scalar", name: { name: "double precision" } },
+    result: { kind: "scalar", name: { name: "double precision" } },
+    description: "square root",
+  },
+
+  {
+    name: { name: "||/" },
+    operand: { kind: "scalar", name: { name: "double precision" } },
+    result: { kind: "scalar", name: { name: "double precision" } },
+    description: "cube root",
+  },
+
+  {
+    name: { name: "~" },
+    operand: { kind: "scalar", name: { name: "bigint" } },
+    result: { kind: "scalar", name: { name: "bigint" } },
+    description: "bitwise not",
+  },
+  {
+    name: { name: "~" },
+    operand: { kind: "scalar", name: { name: "bit" } },
+    result: { kind: "scalar", name: { name: "bit" } },
+    description: "bitwise not",
+  },
+  {
+    name: { name: "~" },
+    operand: { kind: "scalar", name: { name: "inet" } },
+    result: { kind: "scalar", name: { name: "inet" } },
+    description: "bitwise not",
+  },
+  {
+    name: { name: "~" },
+    operand: { kind: "scalar", name: { name: "integer" } },
+    result: { kind: "scalar", name: { name: "integer" } },
+    description: "bitwise not",
+  },
+  {
+    name: { name: "~" },
+    operand: { kind: "scalar", name: { name: "macaddr" } },
+    result: { kind: "scalar", name: { name: "macaddr" } },
+    description: "bitwise not",
+  },
+  {
+    name: { name: "~" },
+    operand: { kind: "scalar", name: { name: "smallint" } },
+    result: { kind: "scalar", name: { name: "smallint" } },
+    description: "bitwise not",
+  },
+];
+
+export const builtinUnaryOperators = builtinunaryoperatorsFromSyntax.concat(
+  builtinunaryoperatorsFromSchema
+);

package/src/cli.ts

@@ -0,0 +1,187 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { CreateFunctionStatement, parse, Statement } from "pgsql-ast-parser";
+import {
+  checkAllCasesHandled,
+  doCreateFunction,
+  functionType,
+  parseSetupScripts,
+  showSqlType,
+  showType,
+  Type,
+} from "./typecheck";
+import * as prettier from "prettier";
+
+go();
+
+async function findSqlFiles(dir: string): Promise<string[]> {
+  const inThisDir = await fs.readdir(dir);
+  const res: string[] = [];
+  for (let p of inThisDir) {
+    const fullP = path.join(dir, p);
+    if (fullP.endsWith(".sql")) {
+      res.push(fullP);
+    } else {
+      const stat = await fs.stat(fullP);
+      if (stat.isDirectory()) {
+        const inSubFolder = await findSqlFiles(fullP);
+        res.push(...inSubFolder);
+      } else {
+        // not a sql file, not a directory
+      }
+    }
+  }
+  return res;
+}
+
+function isCreateFunctionStatement(
+  st: Statement
+): st is CreateFunctionStatement {
+  return st.type === "create function";
+}
+
+export function showTypeAsTypescriptType(t: Type): string {
+  if (t.kind === "set") {
+    return (
+      "{" +
+      t.fields
+        .map(
+          (f) =>
+            (f.name === null ? `"?": ` : `"${f.name.name}": `) +
+            showTypeAsTypescriptType(f.type)
+        )
+        .join(", ") +
+      "}"
+    );
+  } else {
+    if (t.kind === "array") {
+      return "(" + showTypeAsTypescriptType(t.typevar) + ")" + "[]";
+    } else if (t.kind === "nullable") {
+      return showTypeAsTypescriptType(t.typevar) + " | null";
+    } else if (t.kind === "scalar") {
+      if (
+        ["numeric", "bigint", "smallint", "integer", "real", "double"].includes(
+          t.name.name
+        )
+      ) {
+        return "number";
+      } else if (
+        ["text", "name", "char", "character", "varchar", "nvarchar"].includes(
+          t.name.name
+        )
+      ) {
+        return "string";
+      } else if (["bytea"].includes(t.name.name)) {
+        return "Buffer";
+      } else {
+        return t.name.name;
+      }
+    } else if (t.kind === "anyscalar") {
+      return "anyscalar";
+    } else {
+      return checkAllCasesHandled(t);
+    }
+  }
+}
+
+function functionToTypescript(f: functionType): string {
+  const returnTypeAsString =
+    f.returns.kind === "void"
+      ? "void"
+      : showTypeAsTypescriptType(f.returns) + "[]";
+
+  const argsType =
+    "{" +
+    f.inputs
+      .map((k) => {
+        const paramTypeAsString = showTypeAsTypescriptType(k.type);
+
+        // console.log(`Param \$${k.name.name}:\n`, paramTypeAsString, "\n");
+        return k.name.name + ": " + paramTypeAsString;
+      })
+      .join(", ") +
+    "}";
+
+  const argsAsList = f.inputs
+    .map((i) => "${args." + i.name.name + "}")
+    .join(", ");
+
+  const argsForCreateFunction = f.inputs
+    .map((k) => k.name.name + showSqlType(k.type))
+    .join(", ");
+
+  return `
+export function ${
+    f.name.name
+  }(pg: postgres.Sql<any>, args: ${argsType}): Promise<${returnTypeAsString}>{
+return pg\`select ${f.name.name}(${argsAsList})\`;
+/*
+CREATE FUNCTION ${f.name.name}(${argsForCreateFunction}) RETURNS ${
+    f.multipleRows ? "SETOF " : ""
+  }__todo__ AS
+$$${f.code}$$ LANGUAGE ${f.language};
+*/
+}
+`;
+}
+
+async function go() {
+  const dir = process.argv[2];
+  if (!dir) {
+    throw new Error("Please provide directory with SQL files");
+  }
+
+  const outArg = findOutArg(process.argv);
+  if (!outArg) {
+    throw new Error("Please provide -o/--out parameter");
+  }
+  const allSqlFiles = await findSqlFiles(path.resolve(process.cwd(), dir));
+
+  // console.log(`Processing files: ${allSqlFiles.join(", ")}`);
+
+  const allStatements: Statement[] = [];
+  for (let sqlFile of allSqlFiles) {
+    console.log("Processing file ${sqlFile}");
+    const fileContents = await fs.readFile(sqlFile, "utf-8");
+    const statements: Statement[] = parse(fileContents);
+    allStatements.push(...statements);
+  }
+
+  console.log(`Processing ${allStatements.length} statements`);
+
+  const g = parseSetupScripts(allStatements);
+
+  // console.log("Global:\n", JSON.stringify(g, null, 2), "\n");
+
+  const createFunctionStatements = allStatements.filter(
+    isCreateFunctionStatement
+  );
+
+  const outfile = await prepOutFile(path.resolve(process.cwd(), outArg));
+
+  for (let st of createFunctionStatements) {
+    const res = doCreateFunction(g, { decls: [], froms: [] }, st);
+    const writing = prettier.format(functionToTypescript(res), {
+      parser: "typescript",
+    });
+    // console.log(`Writing: ${writing}`);
+    await fs.appendFile(outfile, writing, "utf-8");
+  }
+}
+
+async function prepOutFile(path: string): Promise<string> {
+  // const stat = await fs.stat(path);
+  // if (!stat.isFile)
+  // await fs.truncate(path);
+  await fs.writeFile(path, `import postgres from "postgres";\n`, "utf-8");
+  return path;
+}
+
+function findOutArg(args: string[]): string | null {
+  const flagIndex = args.findIndex((arg) => arg === "-o" || arg === "--out");
+  if (!flagIndex) {
+    return null;
+  } else {
+    return args[flagIndex + 1] || null;
+  }
+}

package/src/readme.md

@@ -0,0 +1,23 @@
+Huidige plan:
+
+We werken niet meer met positionele parameters (da's toch maar een lapmiddel, niet echt deel van Postgres) maar we gaan enkel functies declareren en die typechecken en daar (typescript) bindings van maken. 
+
+Daarmee weet je dus op voorhand welke parameters je hebt. Let bindings, from's etc, kunnen ook wel dingen in de context steken, maar da's wel beter afgelijnd. Die blocks zorgen er wel voor dat immutable Context's wel een goed idee zijn, zo volgen die de flow meteen mee.
+
+Idealiter zouden we LANGUAGE plpgsql en LANGUAGE sql moeten ondersteunen!
+-> Als we beginnen met LANGUAGE sql, dan moeten we (nog) geen parser schrijven!
+
+Type inference:
+* Type is mandatory in DECLARE blocks
+* Type is mandatory in CREATE FUNCTION parameters
+* We kunnen dus aan alle Context.decls meteen een type geven. Enkel nullability heb je niet. 
+  * Of wat als we gewoon alle (user-defined) functie parameters not-nullable by default zetten, en je moet "default NULL" meegeven om ze nullable te definiëren? -> Dit is volgens mij eigenlijk het beste, maar het staat redelijk ver af van hoe Postgres het zelf doet. Op zich voor Aperi zou dit wel goed werken... YUP WE GAAN DIT DOEN
+    * Oude discussie: 
+      * Als we dat immutable willen bijhouden, dan moeten we dus ook weer heel de context de hele tijd meesleuren
+      * Als we dat mutable maken, volg je niet meer de volledige control flow, maar da's ook niet echt nodig denk ik want die moeten altijd "kloppen"
+        * Oude discussie: Moeten we parameters eerste als nullable, of als not-nullable beschouwen?
+          * Indien CALLED ON NULL INPUT (=default): Alles is nullable. (NOPE ZIE VERDER)
+          * Indien RETURNS NULL ON NULL INPUT of STRICT: Niks is nullable? . (NOPE ZIE VERDER)
+            * Eigenlijk betekent dit: Als je mij ergens een NULL geeft, geef ik NULL terug. De body wordt niet uitgevoerd. Dus inderdaad, je gaat altijd in de function body zelf not-nullable zijn! Als je zo'n functie aanroept kan je echter wel NULL terugkrijgen, als een van de argumenten NULL is. Je kan dat als speciale modifier op die functie bijhouden, en als een van de argumenten nullable is, dan is het return type ook nullable.. (NOPE ZIE VERDER)
+            * Optional parameters kunnen we wel nog ondersteunen met "myvar int default NULL". NOPE toch niet, eens STRICT kan je nooit nullable parameters binnenkrijgen. . (NOPE ZIE VERDER)
+            * Moeten we een optie voorzien (of gewoon default zo doen) dat input params aan STRICT functions nooit NULL mogen zijn?