@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.1

package/src/postgres/apply/statements.test.ts

@@ -0,0 +1,155 @@
+import { describe, expect, test } from "vitest";
+import { alterSteps, columnDefinition, constraintSql, createSteps, dropStatement, splitStatements, type PgStep } from "./statements";
+import { declaredObjects } from "./apply";
+import { keyedByQualifiedName, pgSchemaFromLive, type PgSchemaObject } from "../plan/schema";
+import { diffPgSchemas, matchPgObjects } from "../plan/diff";
+import type { LivePgObject } from "../live/catalog";
+
+/** The steps that take the server from `live` to `declared`, one object of a type. */
+function steps(type: string, live: string, declared: string, major = 18): { steps: PgStep[]; unsupported: string[] } {
+  const [obj] = declaredObjects(JSON.stringify({ dialect: "postgres", objects: [{ export: "x", type, ddl: declared, dependsOn: [] }] }));
+  const after: PgSchemaObject[] = keyedByQualifiedName([{ key: "x", canonical: obj!.canonical }]);
+  const before = pgSchemaFromLive([{ type, statement: live, name: "", oid: "1" } as unknown as LivePgObject], "public");
+  const diff = diffPgSchemas(before, after, { major });
+  const m = matchPgObjects(before, after).find((x) => x.kind === "matched")!;
+  const r = alterSteps(obj!, m.before!.canonical, diff.changes, { major });
+  return { steps: r.steps, unsupported: r.unsupported.map((u) => `${u.change.rule}: ${u.why}`) };
+}
+const sql = (r: { steps: PgStep[] }) => r.steps.map((s) => s.sql);
+const T = "Postgres::Table";
+
+describe("columns", () => {
+  test("a type change is ALTER COLUMN TYPE with the declared type, classed a rewrite", () => {
+    const r = steps(T, "CREATE TABLE app.t (id integer)", "CREATE TABLE app.t (id bigint)");
+    expect(sql(r)).toEqual(["ALTER TABLE app.t ALTER COLUMN id TYPE bigint"]);
+    expect(r.steps[0]).toMatchObject({ class: "rewrite", rule: "SQLPG207", transactional: true });
+  });
+
+  test("defaults set and dropped, NOT NULL set and dropped", () => {
+    expect(sql(steps(T, "CREATE TABLE app.t (a text, b text DEFAULT 'x')", "CREATE TABLE app.t (a text DEFAULT 'y', b text)"))).toEqual([
+      "ALTER TABLE app.t ALTER COLUMN a SET DEFAULT 'y'",
+      "ALTER TABLE app.t ALTER COLUMN b DROP DEFAULT",
+    ]);
+    expect(sql(steps(T, "CREATE TABLE app.t (a text, b text NOT NULL)", "CREATE TABLE app.t (a text NOT NULL, b text)"))).toEqual([
+      "ALTER TABLE app.t ALTER COLUMN a SET NOT NULL",
+      "ALTER TABLE app.t ALTER COLUMN b DROP NOT NULL",
+    ]);
+  });
+
+  test("a generated expression is SET EXPRESSION from 17", () => {
+    const r = steps(T, "CREATE TABLE app.t (a int, b int GENERATED ALWAYS AS (a * 2) STORED)", "CREATE TABLE app.t (a int, b int GENERATED ALWAYS AS (a * 3) STORED)");
+    expect(sql(r)).toEqual(["ALTER TABLE app.t ALTER COLUMN b SET EXPRESSION AS (a * 3)"]);
+  });
+
+  test("identity added, and changed in place keeping the sequence", () => {
+    expect(sql(steps(T, "CREATE TABLE app.t (id bigint NOT NULL)", "CREATE TABLE app.t (id bigint GENERATED ALWAYS AS IDENTITY)"))).toEqual([
+      "ALTER TABLE app.t ALTER COLUMN id ADD GENERATED ALWAYS AS IDENTITY",
+    ]);
+    expect(sql(steps(T, "CREATE TABLE app.t (id bigint GENERATED ALWAYS AS IDENTITY)", "CREATE TABLE app.t (id bigint GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 2))"))).toEqual([
+      "ALTER TABLE app.t ALTER COLUMN id SET GENERATED BY DEFAULT SET INCREMENT BY 2 SET NO MINVALUE SET NO MAXVALUE SET CACHE 1 SET NO CYCLE",
+    ]);
+  });
+
+  test("a column's definition for ADD COLUMN leaves its constraints to be added on their own", () => {
+    expect(columnDefinition({ name: "Kind", type: "text", collate: '"C"', default: "'a'", notNull: true })).toBe(`"Kind" text COLLATE "C" DEFAULT 'a' NOT NULL`);
+  });
+});
+
+describe("constraints", () => {
+  test("NOT VALID is added as declared, then validated when NOT VALID goes", () => {
+    const added = steps(T, "CREATE TABLE app.t (a int)", "CREATE TABLE app.t (a int, CONSTRAINT a_pos CHECK (a > 0) NOT VALID)");
+    expect(sql(added)).toEqual(["ALTER TABLE app.t ADD CONSTRAINT a_pos CHECK (a > 0) NOT VALID"]);
+    expect(added.steps[0]).toMatchObject({ class: "metadata", rule: "SQLPG217" });
+    const validated = steps(T, "CREATE TABLE app.t (a int, CONSTRAINT a_pos CHECK (a > 0) NOT VALID)", "CREATE TABLE app.t (a int, CONSTRAINT a_pos CHECK (a > 0))");
+    expect(sql(validated)).toEqual(["ALTER TABLE app.t VALIDATE CONSTRAINT a_pos"]);
+    expect(validated.steps[0]).toMatchObject({ class: "validate", rule: "SQLPG220" });
+  });
+
+  test("a column-level foreign key is added as a table constraint", () => {
+    const r = steps(T, "CREATE TABLE app.o (u bigint)", "CREATE TABLE app.o (u bigint REFERENCES app.users (id) ON DELETE CASCADE)");
+    expect(sql(r)).toEqual(["ALTER TABLE app.o ADD FOREIGN KEY (u) REFERENCES app.users (id) ON DELETE CASCADE"]);
+    expect(r.steps[0]).toMatchObject({ class: "validate", rule: "SQLPG219" });
+  });
+
+  test("a unique constraint is an index built CONCURRENTLY, then the constraint made from it", () => {
+    const r = steps(T, "CREATE TABLE app.t (email text)", "CREATE TABLE app.t (email text UNIQUE)");
+    expect(r.steps).toEqual([
+      { sql: "CREATE UNIQUE INDEX CONCURRENTLY t_email_key ON app.t (email)", class: "concurrently", rule: "SQLPG221", transactional: false, buildsIndex: "app.t_email_key" },
+      { sql: "ALTER TABLE app.t ADD CONSTRAINT t_email_key UNIQUE USING INDEX t_email_key", class: "metadata", rule: "SQLPG221", transactional: true },
+    ]);
+  });
+
+  test("a constraint the declaration lost is dropped by the server's name for it", () => {
+    expect(sql(steps(T, "CREATE TABLE app.t (a int, CONSTRAINT t_a_check CHECK (a > 0))", "CREATE TABLE app.t (a int)"))).toEqual(["ALTER TABLE app.t DROP CONSTRAINT t_a_check"]);
+  });
+
+  test("constraintSql writes each kind as a table constraint", () => {
+    expect(constraintSql("PRIMARY KEY", { name: "pk", columns: ["a", "b"] })).toBe("CONSTRAINT pk PRIMARY KEY (a, b)");
+    expect(constraintSql("EXCLUDE", { using: "gist", elements: "r WITH &&" })).toBe("EXCLUDE USING gist (r WITH &&)");
+  });
+});
+
+describe("other objects", () => {
+  test("enum labels are added in place, each before or after a label that exists, outside a transaction", () => {
+    const r = steps("Postgres::Enum", "CREATE TYPE app.s AS ENUM ('b', 'd')", "CREATE TYPE app.s AS ENUM ('a', 'b', 'c', 'd', 'e')");
+    expect(sql(r)).toEqual([
+      "ALTER TYPE app.s ADD VALUE 'a' BEFORE 'b'",
+      "ALTER TYPE app.s ADD VALUE 'c' AFTER 'b'",
+      "ALTER TYPE app.s ADD VALUE 'e' AFTER 'd'",
+    ]);
+    expect(r.steps.every((s) => !s.transactional)).toBe(true);
+  });
+
+  test("a sequence's options are written whole, defaults included", () => {
+    expect(sql(steps("Postgres::Sequence", "CREATE SEQUENCE app.s", "CREATE SEQUENCE app.s START WITH 1000"))).toEqual([
+      "ALTER SEQUENCE app.s AS bigint INCREMENT BY 1 NO MINVALUE NO MAXVALUE START WITH 1000 CACHE 1 NO CYCLE OWNED BY NONE",
+    ]);
+  });
+
+  test("a view keeping its columns is replaced in place", () => {
+    expect(sql(steps("Postgres::View", "CREATE VIEW app.v AS SELECT 1 AS a", "CREATE VIEW app.v AS SELECT 1 AS a, 2 AS b"))).toEqual(["CREATE OR REPLACE VIEW app.v AS SELECT 1 AS a, 2 AS b"]);
+  });
+
+  test("storage parameters set and reset", () => {
+    expect(sql(steps(T, "CREATE TABLE app.t (a int) WITH (fillfactor = 70, autovacuum_enabled = false)", "CREATE TABLE app.t (a int) WITH (fillfactor = 80)"))).toEqual([
+      "ALTER TABLE app.t SET (fillfactor = 80)",
+      "ALTER TABLE app.t RESET (autovacuum_enabled)",
+    ]);
+  });
+
+  test("a materialized view's query change drops and creates it, marked again", () => {
+    const r = steps("Postgres::MaterializedView", "CREATE MATERIALIZED VIEW app.m AS SELECT 1 AS a", "CREATE MATERIALIZED VIEW app.m AS SELECT 2 AS a");
+    expect(sql(r)).toEqual(["DROP MATERIALIZED VIEW app.m", "CREATE MATERIALIZED VIEW app.m AS SELECT 2 AS a", "COMMENT ON MATERIALIZED VIEW app.m IS '[chant managed-by=chant]'"]);
+    expect(r.steps.every((s) => s.class === "rewrite")).toBe(true);
+  });
+});
+
+describe("create and drop", () => {
+  test("the declared statements run as written, the object's own comment carrying the marker", () => {
+    const [obj] = declaredObjects(
+      JSON.stringify({ dialect: "postgres", objects: [{ export: "u", type: T, dependsOn: [], ddl: "CREATE TABLE app.u (id int);\nCOMMENT ON TABLE app.u IS 'Users';\nCOMMENT ON COLUMN app.u.id IS 'Key'" }] }),
+    );
+    expect(createSteps(obj!, { stack: "s", env: "e" }).map((s) => s.sql)).toEqual([
+      "CREATE TABLE app.u (id int)",
+      "COMMENT ON COLUMN app.u.id IS 'Key'",
+      "COMMENT ON TABLE app.u IS 'Users [chant managed-by=chant stack=s env=e]'",
+    ]);
+  });
+
+  test("a CREATE INDEX CONCURRENTLY refuses a transaction", () => {
+    const [obj] = declaredObjects(JSON.stringify({ dialect: "postgres", objects: [{ export: "i", type: "Postgres::Index", dependsOn: [], ddl: "CREATE INDEX CONCURRENTLY i ON app.u (id)" }] }));
+    expect(createSteps(obj!, undefined)[0]).toMatchObject({ transactional: false, buildsIndex: "app.i" });
+  });
+
+  test("a prune never cascades, and drops an index concurrently", () => {
+    expect(dropStatement("table", "app", "old")).toMatchObject({ sql: "DROP TABLE app.old", transactional: true });
+    expect(dropStatement("index", "app", "old_idx")).toMatchObject({ sql: "DROP INDEX CONCURRENTLY app.old_idx", transactional: false });
+  });
+
+  test("statements split at top-level semicolons only", () => {
+    expect(splitStatements("CREATE TABLE a (t text DEFAULT ';');\n-- note\nCOMMENT ON TABLE a IS 'x; y'").map((s) => s.text)).toEqual([
+      "CREATE TABLE a (t text DEFAULT ';')",
+      "-- note\nCOMMENT ON TABLE a IS 'x; y'",
+    ]);
+  });
+});