@akal/pg-conformance 0.0.0-stage → 0.0.15

package/corpus/migrations.json

@@ -0,0 +1,515 @@
+[
+  {
+    "id": "enum_label_removed",
+    "category": "enum",
+    "description": "An enum loses a label while columns, an array column and defaults use it. There is no DROP VALUE: the columns move to a new type, keeping every row.",
+    "before": "CREATE TYPE st AS ENUM ('new', 'paid', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');",
+    "after": "CREATE TYPE st AS ENUM ('new', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');",
+    "preserve": [
+      "SELECT id, s::text, arr::text, s2::text FROM o ORDER BY id"
+    ]
+  },
+  {
+    "id": "enum_labels_reordered",
+    "category": "enum",
+    "description": "An enum's labels are reordered; the type's sort order changes, the rows do not.",
+    "before": "CREATE TYPE st AS ENUM ('new', 'paid', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');",
+    "after": "CREATE TYPE st AS ENUM ('shipped','paid','new');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');",
+    "preserve": [
+      "SELECT id, s::text, arr::text, s2::text FROM o ORDER BY id"
+    ]
+  },
+  {
+    "id": "enum_label_added",
+    "category": "enum",
+    "description": "An enum gains a label (ALTER TYPE ... ADD VALUE ... AFTER). Its reverse is a removal.",
+    "before": "CREATE TYPE st AS ENUM ('new', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');",
+    "after": "CREATE TYPE st AS ENUM ('new', 'paid', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');",
+    "preserve": [
+      "SELECT id, s::text, arr::text, s2::text FROM o ORDER BY id"
+    ]
+  },
+  {
+    "id": "enum_label_removed_under_readers",
+    "category": "enum",
+    "description": "A label removal with views, a materialized view, a policy, a trigger condition, a generated column, a partial index, a CHECK, a unique key and a foreign key from another table all using the columns.",
+    "before": "CREATE TYPE st AS ENUM ('new', 'paid', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');CREATE VIEW v AS SELECT id, s FROM o WHERE s2 IS NOT NULL; CREATE VIEW v2 AS SELECT * FROM v; CREATE MATERIALIZED VIEW mv AS SELECT s FROM o; CREATE INDEX mv_s ON mv (s); ALTER TABLE o ENABLE ROW LEVEL SECURITY; CREATE POLICY p ON o USING (s = 'new'); CREATE FUNCTION tf() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$; CREATE TRIGGER tr BEFORE UPDATE ON o FOR EACH ROW WHEN (NEW.s = 'new') EXECUTE FUNCTION tf(); ALTER TABLE o ADD COLUMN g boolean GENERATED ALWAYS AS (s = 'new') STORED; CREATE INDEX o_p ON o (id) WHERE s = 'shipped'; ALTER TABLE o ADD CONSTRAINT o_ck CHECK (s <> 'shipped' OR s2 IS NOT NULL); ALTER TABLE o ADD CONSTRAINT o_u UNIQUE (s, id); CREATE TABLE r (id int, s st, FOREIGN KEY (s, id) REFERENCES o (s, id));",
+    "after": "CREATE TYPE st AS ENUM ('new', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');CREATE VIEW v AS SELECT id, s FROM o WHERE s2 IS NOT NULL; CREATE VIEW v2 AS SELECT * FROM v; CREATE MATERIALIZED VIEW mv AS SELECT s FROM o; CREATE INDEX mv_s ON mv (s); ALTER TABLE o ENABLE ROW LEVEL SECURITY; CREATE POLICY p ON o USING (s = 'new'); CREATE FUNCTION tf() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$; CREATE TRIGGER tr BEFORE UPDATE ON o FOR EACH ROW WHEN (NEW.s = 'new') EXECUTE FUNCTION tf(); ALTER TABLE o ADD COLUMN g boolean GENERATED ALWAYS AS (s = 'new') STORED; CREATE INDEX o_p ON o (id) WHERE s = 'shipped'; ALTER TABLE o ADD CONSTRAINT o_ck CHECK (s <> 'shipped' OR s2 IS NOT NULL); ALTER TABLE o ADD CONSTRAINT o_u UNIQUE (s, id); CREATE TABLE r (id int, s st, FOREIGN KEY (s, id) REFERENCES o (s, id));",
+    "preserve": [
+      "SELECT id, s::text, s2::text FROM o ORDER BY id"
+    ]
+  },
+  {
+    "id": "enum_label_added_under_readers",
+    "category": "enum",
+    "description": "The same readers, with a label added instead; reverting it is a removal under all of them.",
+    "before": "CREATE TYPE st AS ENUM ('new', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');CREATE VIEW v AS SELECT id, s FROM o WHERE s2 IS NOT NULL; CREATE VIEW v2 AS SELECT * FROM v; CREATE MATERIALIZED VIEW mv AS SELECT s FROM o; CREATE INDEX mv_s ON mv (s); ALTER TABLE o ENABLE ROW LEVEL SECURITY; CREATE POLICY p ON o USING (s = 'new'); CREATE FUNCTION tf() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$; CREATE TRIGGER tr BEFORE UPDATE ON o FOR EACH ROW WHEN (NEW.s = 'new') EXECUTE FUNCTION tf(); ALTER TABLE o ADD COLUMN g boolean GENERATED ALWAYS AS (s = 'new') STORED; CREATE INDEX o_p ON o (id) WHERE s = 'shipped'; ALTER TABLE o ADD CONSTRAINT o_ck CHECK (s <> 'shipped' OR s2 IS NOT NULL); ALTER TABLE o ADD CONSTRAINT o_u UNIQUE (s, id); CREATE TABLE r (id int, s st, FOREIGN KEY (s, id) REFERENCES o (s, id));",
+    "after": "CREATE TYPE st AS ENUM ('new', 'paid', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');CREATE VIEW v AS SELECT id, s FROM o WHERE s2 IS NOT NULL; CREATE VIEW v2 AS SELECT * FROM v; CREATE MATERIALIZED VIEW mv AS SELECT s FROM o; CREATE INDEX mv_s ON mv (s); ALTER TABLE o ENABLE ROW LEVEL SECURITY; CREATE POLICY p ON o USING (s = 'new'); CREATE FUNCTION tf() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$; CREATE TRIGGER tr BEFORE UPDATE ON o FOR EACH ROW WHEN (NEW.s = 'new') EXECUTE FUNCTION tf(); ALTER TABLE o ADD COLUMN g boolean GENERATED ALWAYS AS (s = 'new') STORED; CREATE INDEX o_p ON o (id) WHERE s = 'shipped'; ALTER TABLE o ADD CONSTRAINT o_ck CHECK (s <> 'shipped' OR s2 IS NOT NULL); ALTER TABLE o ADD CONSTRAINT o_u UNIQUE (s, id); CREATE TABLE r (id int, s st, FOREIGN KEY (s, id) REFERENCES o (s, id));",
+    "preserve": [
+      "SELECT id, s::text, s2::text FROM o ORDER BY id"
+    ]
+  },
+  {
+    "id": "enum_label_removed_with_constraint_naming_it",
+    "category": "enum",
+    "description": "The label being removed is named by a CHECK and a partial index that go with it; they cannot be put back around the swap.",
+    "before": "CREATE TYPE st AS ENUM ('new', 'paid', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');ALTER TABLE o ADD CONSTRAINT ck_paid CHECK (s <> 'paid'); CREATE INDEX o_paid ON o (id) WHERE s = 'paid';",
+    "after": "CREATE TYPE st AS ENUM ('new', 'shipped');CREATE TABLE o (id int PRIMARY KEY, s st NOT NULL DEFAULT 'new', arr st[] DEFAULT '{new}', s2 st); INSERT INTO o VALUES (1,'new','{new,shipped}','shipped'),(2,'shipped',NULL,'new');"
+  },
+  {
+    "id": "identity_kind_changed",
+    "category": "identity",
+    "description": "GENERATED BY DEFAULT becomes ALWAYS on a column with rows. Dropping and re-adding the identity restarts the sequence and the next insert collides.",
+    "before": "CREATE TABLE t (id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, v int);INSERT INTO t (v) SELECT g FROM generate_series(1,5) g;",
+    "after": "CREATE TABLE t (id int GENERATED ALWAYS AS IDENTITY PRIMARY KEY, v int);INSERT INTO t (v) SELECT g FROM generate_series(1,5) g;",
+    "preserve": [
+      "SELECT id, v FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "identity_options_changed",
+    "category": "identity",
+    "description": "An identity gains INCREMENT BY 10; the sequence keeps its position.",
+    "before": "CREATE TABLE t (id int GENERATED ALWAYS AS IDENTITY PRIMARY KEY, v int);INSERT INTO t (v) SELECT g FROM generate_series(1,5) g;",
+    "after": "CREATE TABLE t (id int GENERATED ALWAYS AS IDENTITY (INCREMENT BY 10) PRIMARY KEY, v int);INSERT INTO t (v) SELECT g FROM generate_series(1,5) g;",
+    "preserve": [
+      "SELECT id, v FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "identity_retyped",
+    "category": "identity",
+    "description": "An identity column goes from int to bigint.",
+    "before": "CREATE TABLE t (id int GENERATED ALWAYS AS IDENTITY PRIMARY KEY, v int);INSERT INTO t (v) SELECT g FROM generate_series(1,5) g;",
+    "after": "CREATE TABLE t (id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, v int);INSERT INTO t (v) SELECT g FROM generate_series(1,5) g;",
+    "preserve": [
+      "SELECT id, v FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "plain_column_becomes_identity",
+    "category": "identity",
+    "description": "A plain integer key with rows becomes an identity; its sequence must start past the existing values.",
+    "before": "CREATE TABLE t (id int PRIMARY KEY, v int); INSERT INTO t VALUES (1,1),(2,2);",
+    "after": "CREATE TABLE t (id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, v int);",
+    "preserve": [
+      "SELECT id, v FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "serial_becomes_identity",
+    "category": "serial",
+    "description": "A serial column becomes an identity: its default and owned sequence go, the identity starts past the rows.",
+    "before": "CREATE TABLE t (id serial PRIMARY KEY, v int);INSERT INTO t (v) SELECT g FROM generate_series(1,5) g;",
+    "after": "CREATE TABLE t (id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, v int);",
+    "preserve": [
+      "SELECT id, v FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "identity_becomes_serial",
+    "category": "serial",
+    "description": "An identity becomes a serial column: a sequence owned by it, a nextval default, started past the rows.",
+    "before": "CREATE TABLE t (id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, v int);INSERT INTO t (v) SELECT g FROM generate_series(1,5) g;",
+    "after": "CREATE TABLE t (id serial PRIMARY KEY, v int);",
+    "preserve": [
+      "SELECT id, v FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "serial_becomes_bigserial",
+    "category": "serial",
+    "description": "serial becomes bigserial. ALTER COLUMN TYPE does not retype the sequence, which must follow or it still stops at 2^31.",
+    "before": "CREATE TABLE t (id serial, v int);INSERT INTO t (v) SELECT g FROM generate_series(1,5) g;",
+    "after": "CREATE TABLE t (id bigserial, v int);INSERT INTO t (v) SELECT g FROM generate_series(1,5) g;",
+    "preserve": [
+      "SELECT id, v FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "column_storage_and_compression",
+    "category": "storage",
+    "description": "A column gains COMPRESSION lz4 and another STORAGE EXTERNAL.",
+    "before": "CREATE TABLE t (id int, body text, blob bytea);",
+    "after": "CREATE TABLE t (id int, body text COMPRESSION lz4, blob bytea); ALTER TABLE t ALTER COLUMN blob SET STORAGE EXTERNAL;"
+  },
+  {
+    "id": "retype_resets_storage_and_compression",
+    "category": "storage",
+    "description": "A column is retyped and must keep its storage and compression, which ALTER COLUMN TYPE resets to the new type's defaults.",
+    "before": "CREATE TABLE t (id int, body varchar(200));",
+    "after": "CREATE TABLE t (id int, body text COMPRESSION lz4); ALTER TABLE t ALTER COLUMN body SET STORAGE EXTERNAL;"
+  },
+  {
+    "id": "generated_expression_changed",
+    "category": "generated",
+    "description": "A stored generated column's expression changes; it can only be dropped and re-added, recomputed.",
+    "before": "CREATE TABLE t (id int primary key, a numeric, g numeric GENERATED ALWAYS AS (a * 2) STORED); INSERT INTO t VALUES (1, 2);",
+    "after": "CREATE TABLE t (id int primary key, a numeric, g numeric GENERATED ALWAYS AS (a * 3) STORED); INSERT INTO t VALUES (1, 2);",
+    "preserve": [
+      "SELECT id, a FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "plain_column_becomes_generated",
+    "category": "generated",
+    "description": "A plain column becomes a stored generated one.",
+    "before": "CREATE TABLE t (id int, a int, b int GENERATED ALWAYS AS (a*2) STORED); INSERT INTO t (id,a) VALUES (1,2);",
+    "after": "CREATE TABLE t (id int, a int, b int); INSERT INTO t VALUES (1,2,4);"
+  },
+  {
+    "id": "generated_column_becomes_plain",
+    "category": "generated",
+    "description": "A stored generated column becomes plain (DROP EXPRESSION), keeping its values.",
+    "before": "CREATE TABLE t (id int, a int, b int); INSERT INTO t VALUES (1,2,4);",
+    "after": "CREATE TABLE t (id int, a int, b int GENERATED ALWAYS AS (a*2) STORED); INSERT INTO t (id,a) VALUES (1,2);"
+  },
+  {
+    "id": "retype_under_views_and_policies",
+    "category": "dependants",
+    "description": "Columns retyped (numeric precision, text to uuid) under a security_invoker view with grants and a policy, which PostgreSQL refuses to retype under.",
+    "before": "CREATE TABLE t (id int PRIMARY KEY, a numeric(10,2), uid text); CREATE VIEW v WITH (security_invoker=true) AS SELECT id, a FROM t; GRANT SELECT ON v TO PUBLIC; ALTER TABLE t ENABLE ROW LEVEL SECURITY; CREATE POLICY p ON t USING (uid IS NOT NULL);",
+    "after": "CREATE TABLE t (id int PRIMARY KEY, a numeric(12,2), uid uuid); CREATE VIEW v WITH (security_invoker=true) AS SELECT id, a FROM t; GRANT SELECT ON v TO PUBLIC; ALTER TABLE t ENABLE ROW LEVEL SECURITY; CREATE POLICY p ON t USING (uid IS NOT NULL);",
+    "minPgVersion": 15
+  },
+  {
+    "id": "retype_partitioned_column",
+    "category": "dependants",
+    "description": "A column retyped on a partitioned table read by a view; the partitions follow the parent.",
+    "before": "CREATE TABLE p (id int, a numeric(10,2)) PARTITION BY RANGE (id); CREATE TABLE p1 PARTITION OF p FOR VALUES FROM (0) TO (100); CREATE VIEW pv AS SELECT a FROM p;",
+    "after": "CREATE TABLE p (id int, a numeric(12,2)) PARTITION BY RANGE (id); CREATE TABLE p1 PARTITION OF p FOR VALUES FROM (0) TO (100); CREATE VIEW pv AS SELECT a FROM p;"
+  },
+  {
+    "id": "new_enum_typed_column",
+    "category": "creation_order",
+    "description": "A new column typed by a new enum: the type is created first, and dropped last when reverting.",
+    "before": "CREATE TABLE t (id int);",
+    "after": "CREATE TYPE e AS ENUM ('a'); CREATE TABLE t (id int, c e);"
+  },
+  {
+    "id": "new_domain_over_new_enum",
+    "category": "creation_order",
+    "description": "A new column typed by a new domain over a new enum.",
+    "before": "CREATE TABLE t (id int);",
+    "after": "CREATE TYPE e AS ENUM ('a'); CREATE DOMAIN d AS e; CREATE TABLE t (id int, c d);"
+  },
+  {
+    "id": "new_sequence_default",
+    "category": "creation_order",
+    "description": "A new column defaulting to nextval() of a new sequence.",
+    "before": "CREATE TABLE t (id int);",
+    "after": "CREATE SEQUENCE s; CREATE TABLE t (id int DEFAULT nextval('s'));"
+  },
+  {
+    "id": "new_function_in_default",
+    "category": "creation_order",
+    "description": "A new column whose default calls a new function: the function must exist first, although functions are otherwise created after tables.",
+    "before": "CREATE TABLE t (id int);",
+    "after": "CREATE FUNCTION f() RETURNS int LANGUAGE sql IMMUTABLE AS $$ SELECT 7 $$;CREATE TABLE t (id int DEFAULT f());"
+  },
+  {
+    "id": "new_function_in_check",
+    "category": "creation_order",
+    "description": "A new CHECK constraint calling a new function.",
+    "before": "CREATE TABLE t (id int);",
+    "after": "CREATE FUNCTION f() RETURNS int LANGUAGE sql IMMUTABLE AS $$ SELECT 7 $$;CREATE TABLE t (id int CHECK (id < f() * 100));"
+  },
+  {
+    "id": "new_function_in_index",
+    "category": "creation_order",
+    "description": "A new expression index calling a new function.",
+    "before": "CREATE TABLE t (id int);",
+    "after": "CREATE FUNCTION f() RETURNS int LANGUAGE sql IMMUTABLE AS $$ SELECT 7 $$;CREATE TABLE t (id int); CREATE INDEX t_f ON t ((id + f()));"
+  },
+  {
+    "id": "new_function_with_arguments_in_default",
+    "category": "creation_order",
+    "description": "A new default calling a new function with arguments, identified by its signature.",
+    "before": "CREATE TABLE t (id int);",
+    "after": "CREATE FUNCTION addn(x integer) RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT x + 1 $$; CREATE TABLE t (id int DEFAULT addn(1));"
+  },
+  {
+    "id": "new_trigger_and_its_function",
+    "category": "creation_order",
+    "description": "A new trigger with its new trigger function.",
+    "before": "CREATE TABLE t (id int);",
+    "after": "CREATE TABLE t (id int); CREATE FUNCTION tfn() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$; CREATE TRIGGER tr BEFORE INSERT ON t FOR EACH ROW EXECUTE FUNCTION tfn();"
+  },
+  {
+    "id": "new_table_typed_by_new_enum",
+    "category": "creation_order",
+    "description": "A new table with a column typed by a new enum: the type is created before the table, and dropped after it when reverting.",
+    "before": "CREATE TABLE keep (id int);",
+    "after": "CREATE TABLE keep (id int); CREATE TYPE e AS ENUM ('a'); CREATE TABLE t (id int, c e);"
+  },
+  {
+    "id": "new_domain_typed_column",
+    "category": "creation_order",
+    "description": "A new column typed by a new domain with a CHECK: the domain is created first, and dropped last when reverting.",
+    "before": "CREATE TABLE t (id int);",
+    "after": "CREATE DOMAIN d AS int CHECK (VALUE > 0); CREATE TABLE t (id int, c d);"
+  },
+  {
+    "id": "new_function_with_defaulted_argument_in_default_and_check",
+    "category": "creation_order",
+    "description": "A new function whose second argument has a default, called with one argument from a column default and a CHECK: identified by its full signature, and created before both.",
+    "before": "CREATE TABLE t (id int);",
+    "after": "CREATE FUNCTION addn(x integer, y text DEFAULT $$a$$) RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT x + 1 $$; CREATE TABLE t (id int DEFAULT addn(1), c int CHECK (c < addn(100)));"
+  },
+  {
+    "id": "default_changed_to_call_new_function",
+    "category": "creation_order",
+    "description": "An existing column's default changes to call a new function: the function is created before the default is set, and dropped after it is restored when reverting.",
+    "before": "CREATE TABLE t (id int DEFAULT 0);",
+    "after": "CREATE FUNCTION addn(x integer, y text DEFAULT $$a$$) RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT x + 1 $$; CREATE TABLE t (id int DEFAULT addn(5));"
+  },
+  {
+    "id": "new_function_reading_new_table",
+    "category": "creation_order",
+    "description": "A new SQL function reading a new table: SQL function bodies are checked when created, so the table comes first, and goes last when reverting.",
+    "before": "CREATE TABLE keep (id int);",
+    "after": "CREATE TABLE keep (id int); CREATE TABLE t (id int); CREATE FUNCTION n() RETURNS bigint LANGUAGE sql AS $$ SELECT count(*) FROM t $$;"
+  },
+  {
+    "id": "removed_enum_used_everywhere",
+    "category": "removal_order",
+    "description": "An enum the desired schema no longer has, used by a domain, a column, a function argument and a view: it is dropped last, and recreated first when reverting.",
+    "before": "CREATE TYPE e AS ENUM ('a','b'); CREATE DOMAIN d AS e; CREATE TABLE t (id int, c e); CREATE FUNCTION fe(x e) RETURNS int LANGUAGE sql AS $$ SELECT 1 $$; CREATE VIEW v AS SELECT id, c, 'a'::e AS k FROM t;",
+    "after": "CREATE TABLE t (id int);"
+  },
+  {
+    "id": "removed_sequence_and_function_in_defaults",
+    "category": "removal_order",
+    "description": "A sequence and a function used only by defaults of columns that go too.",
+    "before": "CREATE SEQUENCE s; CREATE FUNCTION g() RETURNS int LANGUAGE sql AS $$ SELECT 1 $$; CREATE TABLE t (id int DEFAULT nextval('s'), x int DEFAULT g());",
+    "after": "CREATE TABLE t (id int);"
+  },
+  {
+    "id": "removed_table_typed_by_removed_enum",
+    "category": "removal_order",
+    "description": "A table with a view on it, typed by an enum that goes with it.",
+    "before": "CREATE TYPE e AS ENUM ('a'); CREATE TABLE t (id int); CREATE TABLE t2 (id int, c e); CREATE VIEW v2 AS SELECT * FROM t2;",
+    "after": "CREATE TABLE t (id int);"
+  },
+  {
+    "id": "removed_function_reading_removed_table",
+    "category": "removal_order",
+    "description": "A SQL function reading a table that goes too; when reverting, the table must be back before the function body is validated.",
+    "before": "CREATE TABLE t (id int); CREATE TABLE t2 (id int); CREATE FUNCTION n() RETURNS bigint LANGUAGE sql AS $$ SELECT count(*) FROM t2 $$;",
+    "after": "CREATE TABLE t (id int);"
+  },
+  {
+    "id": "removed_trigger_on_removed_table",
+    "category": "removal_order",
+    "description": "A trigger and its function on a table that goes too.",
+    "before": "CREATE TABLE t (id int); CREATE TABLE t2 (id int); CREATE FUNCTION tfn() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$; CREATE TRIGGER tr BEFORE INSERT ON t2 FOR EACH ROW EXECUTE FUNCTION tfn();",
+    "after": "CREATE TABLE t (id int);"
+  },
+  {
+    "id": "removed_composite_over_removed_enum",
+    "category": "removal_order",
+    "description": "A column typed by a composite holding an enum; all three go.",
+    "before": "CREATE TYPE e AS ENUM ('a'); CREATE TYPE c AS (x e, y int); CREATE TABLE t (id int, v c);",
+    "after": "CREATE TABLE t (id int);"
+  },
+  {
+    "id": "removed_function_in_check_and_index",
+    "category": "removal_order",
+    "description": "A function used by a CHECK and an expression index that go first.",
+    "before": "CREATE FUNCTION lim() RETURNS int LANGUAGE sql IMMUTABLE AS $$ SELECT 10 $$; CREATE TABLE t (id int CHECK (id < lim())); CREATE INDEX t_l ON t ((id + lim()));",
+    "after": "CREATE TABLE t (id int);"
+  },
+  {
+    "id": "foreign_key_onto_another_schema",
+    "category": "foreign_key",
+    "description": "A foreign key onto a table in another schema, as every Supabase table referencing auth.users has; the reference must keep its schema.",
+    "before": "CREATE SCHEMA app; CREATE TABLE app.users (id int PRIMARY KEY); CREATE TABLE p (a int, b int, PRIMARY KEY (a, b)); CREATE TABLE profiles (id int, user_id int);",
+    "after": "CREATE SCHEMA app; CREATE TABLE app.users (id int PRIMARY KEY); CREATE TABLE p (a int, b int, PRIMARY KEY (a, b)); CREATE TABLE profiles (id int, user_id int REFERENCES app.users (id));"
+  },
+  {
+    "id": "foreign_key_over_two_columns",
+    "category": "foreign_key",
+    "description": "A foreign key over two columns; the reference must list both.",
+    "before": "CREATE SCHEMA app; CREATE TABLE app.users (id int PRIMARY KEY); CREATE TABLE p (a int, b int, PRIMARY KEY (a, b)); CREATE TABLE c (x int, y int);",
+    "after": "CREATE SCHEMA app; CREATE TABLE app.users (id int PRIMARY KEY); CREATE TABLE p (a int, b int, PRIMARY KEY (a, b)); CREATE TABLE c (x int, y int, FOREIGN KEY (x, y) REFERENCES p (a, b));"
+  },
+  {
+    "id": "foreign_keys_on_new_table",
+    "category": "foreign_key",
+    "description": "A new table with both a key onto another schema's table and a key over two columns: each reference must keep its schema and every column.",
+    "before": "CREATE SCHEMA app; CREATE TABLE app.users (id int PRIMARY KEY); CREATE TABLE p (a int, b int, PRIMARY KEY (a, b));",
+    "after": "CREATE SCHEMA app; CREATE TABLE app.users (id int PRIMARY KEY); CREATE TABLE p (a int, b int, PRIMARY KEY (a, b)); CREATE TABLE profiles (id int, user_id int REFERENCES app.users (id), x int, y int, FOREIGN KEY (x, y) REFERENCES p (a, b));"
+  },
+  {
+    "id": "objects_in_quoted_schema",
+    "category": "schemas",
+    "description": "A schema, table, columns and index whose names need quoting — spaces, capitals, a reserved word, non-ASCII — with a view and a column comment. Every name must stay quoted, in the right schema.",
+    "before": "CREATE SCHEMA \"App Data\"; CREATE TABLE \"App Data\".\"Order Items\" (\"ID\" int PRIMARY KEY, \"Qty\" int, \"select\" text);",
+    "after": "CREATE SCHEMA \"App Data\"; CREATE TABLE \"App Data\".\"Order Items\" (\"ID\" int PRIMARY KEY, \"Qty\" int NOT NULL DEFAULT 1, \"select\" text, \"ünïcödé\" text); CREATE INDEX \"Qty Idx\" ON \"App Data\".\"Order Items\" (\"Qty\"); CREATE VIEW \"App Data\".\"Big Orders\" AS SELECT \"ID\", \"Qty\" FROM \"App Data\".\"Order Items\" WHERE \"Qty\" > 10; COMMENT ON COLUMN \"App Data\".\"Order Items\".\"select\" IS 'reserved word';"
+  },
+  {
+    "id": "objects_in_another_schema",
+    "category": "schemas",
+    "description": "An enum, a table with a deferrable foreign key and a function, all in a schema other than public. A tool that looks only at public reports the two databases identical.",
+    "before": "CREATE SCHEMA app; CREATE TABLE app.accounts (id int PRIMARY KEY);",
+    "after": "CREATE SCHEMA app; CREATE TYPE app.tier AS ENUM ('free', 'pro'); CREATE TABLE app.accounts (id int PRIMARY KEY, tier app.tier NOT NULL DEFAULT 'free'); CREATE TABLE app.invoices (id int PRIMARY KEY, account_id int REFERENCES app.accounts (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED); CREATE FUNCTION app.tier_of(int) RETURNS app.tier LANGUAGE sql STABLE AS $$ SELECT tier FROM app.accounts WHERE id = $1 $$;"
+  },
+  {
+    "id": "function_overloads",
+    "category": "routines",
+    "description": "Three functions of one name told apart by their arguments: one's body changes, one is unchanged, one is new and has a defaulted argument.",
+    "before": "CREATE FUNCTION f(x int) RETURNS int LANGUAGE sql AS $$ SELECT x $$; CREATE FUNCTION f(x text) RETURNS text LANGUAGE sql AS $$ SELECT x $$;",
+    "after": "CREATE FUNCTION f(x int) RETURNS int LANGUAGE sql AS $$ SELECT x + 1 $$; CREATE FUNCTION f(x text) RETURNS text LANGUAGE sql AS $$ SELECT x $$; CREATE FUNCTION f(x int, y int DEFAULT 0) RETURNS int LANGUAGE sql AS $$ SELECT x + y $$;"
+  },
+  {
+    "id": "partitions_added_with_default_and_index",
+    "category": "partitions",
+    "description": "A range-partitioned table gains a partition, a default partition and an index on the parent. The index must reach every partition, the new ones included.",
+    "before": "CREATE TABLE ev (id int, at date NOT NULL, kind text) PARTITION BY RANGE (at); CREATE TABLE ev_2025 PARTITION OF ev FOR VALUES FROM ('2025-01-01') TO ('2026-01-01');",
+    "after": "CREATE TABLE ev (id int, at date NOT NULL, kind text) PARTITION BY RANGE (at); CREATE TABLE ev_2025 PARTITION OF ev FOR VALUES FROM ('2025-01-01') TO ('2026-01-01'); CREATE TABLE ev_2026 PARTITION OF ev FOR VALUES FROM ('2026-01-01') TO ('2027-01-01'); CREATE TABLE ev_other PARTITION OF ev DEFAULT; CREATE INDEX ev_kind ON ev (kind);"
+  },
+  {
+    "id": "rls_forced_with_restrictive_policy",
+    "category": "rls",
+    "description": "Row level security enabled and forced, a permissive SELECT policy and a restrictive INSERT policy with a WITH CHECK.",
+    "before": "CREATE TABLE docs (id int PRIMARY KEY, owner text, body text);",
+    "after": "CREATE TABLE docs (id int PRIMARY KEY, owner text, body text); ALTER TABLE docs ENABLE ROW LEVEL SECURITY; ALTER TABLE docs FORCE ROW LEVEL SECURITY; CREATE POLICY docs_read ON docs FOR SELECT USING (owner = current_user); CREATE POLICY docs_write ON docs AS RESTRICTIVE FOR INSERT WITH CHECK (owner = current_user AND length(body) < 1000);"
+  },
+  {
+    "id": "trigger_with_condition_and_indexed_matview",
+    "category": "triggers",
+    "description": "A trigger on an UPDATE OF one column with a WHEN condition, its function, and a materialized view with a unique index and a comment.",
+    "before": "CREATE TABLE t (id int PRIMARY KEY, n int, touched timestamptz);",
+    "after": "CREATE TABLE t (id int PRIMARY KEY, n int, touched timestamptz); CREATE FUNCTION touch() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN NEW.touched := now(); RETURN NEW; END $$; CREATE TRIGGER t_touch BEFORE UPDATE OF n ON t FOR EACH ROW WHEN (OLD.n IS DISTINCT FROM NEW.n) EXECUTE FUNCTION touch(); CREATE MATERIALIZED VIEW t_sum AS SELECT count(*) AS c, sum(n) AS s FROM t; CREATE UNIQUE INDEX t_sum_c ON t_sum (c); COMMENT ON MATERIALIZED VIEW t_sum IS 'rollup';"
+  },
+  {
+    "id": "column_types_defaults_and_collation",
+    "category": "types",
+    "description": "Columns with an array default, a jsonb default, an interval default, a domain with its own default and CHECK, an explicit collation and an identity with START and INCREMENT.",
+    "before": "CREATE TABLE ty (id int PRIMARY KEY);",
+    "after": "CREATE DOMAIN pos AS numeric(12,4) DEFAULT 0 CHECK (VALUE >= 0); CREATE TABLE ty (id int PRIMARY KEY, tags text[] DEFAULT '{}', meta jsonb NOT NULL DEFAULT '{\"a\": 1}'::jsonb, wait interval DEFAULT '5 minutes', amt pos, name text COLLATE \"C\", seq_n bigint GENERATED BY DEFAULT AS IDENTITY (START WITH 100 INCREMENT BY 5));"
+  },
+  {
+    "id": "sequence_shared_and_owned_with_options",
+    "category": "sequences",
+    "description": "A standalone sequence with START and CACHE, used by two tables' defaults and owned by one table's column. Its options must survive, and it is a sequence of its own, not a serial.",
+    "before": "CREATE TABLE a (id int PRIMARY KEY);",
+    "after": "CREATE SEQUENCE shared_seq START 1000 CACHE 10; CREATE TABLE a (id int PRIMARY KEY DEFAULT nextval('shared_seq')); CREATE TABLE b (id int PRIMARY KEY DEFAULT nextval('shared_seq')); ALTER SEQUENCE shared_seq OWNED BY a.id;"
+  },
+  {
+    "id": "deferrable_unique_check_and_partial_expression_index",
+    "category": "constraints",
+    "description": "A deferrable UNIQUE constraint, a CHECK across two columns and a partial unique index on an expression.",
+    "before": "CREATE TABLE cu (id int PRIMARY KEY, email text, a int, b int);",
+    "after": "CREATE TABLE cu (id int PRIMARY KEY, email text, a int, b int, CONSTRAINT cu_email UNIQUE (email) DEFERRABLE, CONSTRAINT cu_ab CHECK (a < b)); CREATE UNIQUE INDEX cu_lower ON cu (lower(email)) WHERE email IS NOT NULL;"
+  },
+  {
+    "id": "policy_follows_column_retype_beside_serial_to_identity",
+    "category": "ordering",
+    "description": "A policy compares a column to uid() once the column becomes uuid, while another table's serial becomes an identity. The policy can only be created after the retype; run before it, it fails with: operator does not exist: text = uuid.",
+    "before": "CREATE FUNCTION uid() RETURNS uuid LANGUAGE sql STABLE AS $$ SELECT '00000000-0000-0000-0000-000000000001'::uuid $$; CREATE TABLE a_orders (id serial PRIMARY KEY, total int); CREATE TABLE p_profiles (id int PRIMARY KEY, user_id text); ALTER TABLE p_profiles ENABLE ROW LEVEL SECURITY; CREATE POLICY own ON p_profiles USING (user_id = uid()::text);",
+    "after": "CREATE FUNCTION uid() RETURNS uuid LANGUAGE sql STABLE AS $$ SELECT '00000000-0000-0000-0000-000000000001'::uuid $$; CREATE TABLE a_orders (id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, total int); CREATE TABLE p_profiles (id int PRIMARY KEY, user_id uuid); ALTER TABLE p_profiles ENABLE ROW LEVEL SECURITY; CREATE POLICY own ON p_profiles USING (user_id = uid());"
+  },
+  {
+    "id": "schema_created_with_references_across_schemas",
+    "category": "schemas",
+    "description": "A new schema with a type and a table whose key references a new table in public, and a public view reading the new schema. The schema comes first, the referenced table before the one referencing it whatever their schemas' names, and the view last; the reverse drops the schema once it is empty.",
+    "before": "CREATE TABLE unrelated (id int PRIMARY KEY);",
+    "after": "CREATE TABLE unrelated (id int PRIMARY KEY); CREATE TABLE customers (id int PRIMARY KEY); CREATE SCHEMA billing; CREATE TYPE billing.state AS ENUM ('open', 'paid'); CREATE TABLE billing.invoices (id int PRIMARY KEY, customer_id int NOT NULL REFERENCES public.customers (id), state billing.state NOT NULL DEFAULT 'open'); CREATE VIEW open_invoices AS SELECT id, customer_id FROM billing.invoices WHERE state = 'open';"
+  },
+  {
+    "id": "same_table_name_in_two_schemas",
+    "category": "schemas",
+    "description": "Tables of one name in two schemas change differently; each change must land on its own table.",
+    "before": "CREATE SCHEMA a; CREATE SCHEMA b; CREATE TABLE a.t (id int PRIMARY KEY); CREATE TABLE b.t (id int PRIMARY KEY, y int); INSERT INTO a.t VALUES (1), (2); INSERT INTO b.t VALUES (1, 5);",
+    "after": "CREATE SCHEMA a; CREATE SCHEMA b; CREATE TABLE a.t (id int PRIMARY KEY, x text NOT NULL DEFAULT ''); CREATE TABLE b.t (id int PRIMARY KEY); CREATE INDEX t_x ON a.t (x); INSERT INTO a.t VALUES (1, 'p'), (2, 'q'); INSERT INTO b.t VALUES (1);",
+    "preserve": [
+      "SELECT id FROM a.t ORDER BY id",
+      "SELECT id FROM b.t ORDER BY id"
+    ]
+  },
+  {
+    "id": "indexed_column_added",
+    "category": "indexes",
+    "description": "A column arrives with an index on it. Dropping the column takes the index with it, so the reverse drops the index first; dropped after, it no longer exists.",
+    "before": "CREATE TABLE t (id int PRIMARY KEY); INSERT INTO t VALUES (1), (2);",
+    "after": "CREATE TABLE t (id int PRIMARY KEY, x text); CREATE INDEX t_x ON t (x); CREATE UNIQUE INDEX t_lower_x ON t (lower(x)) WHERE x IS NOT NULL; INSERT INTO t VALUES (1, 'a'), (2, 'b');",
+    "preserve": [
+      "SELECT id FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "comment_on_a_column_added_last",
+    "category": "comments",
+    "description": "A commented column the target gains after its other columns, so its position differs from the source's. The same comment on the same column is no difference: comments are compared by the column's name, never its position.",
+    "before": "CREATE TABLE t (id int PRIMARY KEY, note text); INSERT INTO t VALUES (1, 'a');",
+    "after": "CREATE TABLE t (id int PRIMARY KEY, tier text NOT NULL DEFAULT 'free', note text); COMMENT ON COLUMN t.tier IS 'billing tier'; COMMENT ON COLUMN t.note IS 'free text'; INSERT INTO t VALUES (1, 'free', 'a');",
+    "preserve": [
+      "SELECT id, note FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "check_added_not_valid",
+    "category": "constraints",
+    "description": "A check added NOT VALID over a row it does not hold for. It must arrive NOT VALID: validated, as it would be inside CREATE TABLE, it would refuse the row it was added beside.",
+    "before": "CREATE TABLE t (id int PRIMARY KEY, n int); INSERT INTO t VALUES (1, -5), (2, 3);",
+    "after": "CREATE TABLE t (id int PRIMARY KEY, n int); INSERT INTO t VALUES (1, -5), (2, 3); ALTER TABLE t ADD CONSTRAINT t_n_positive CHECK (n > 0) NOT VALID;",
+    "preserve": [
+      "SELECT id, n FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "circular_foreign_keys",
+    "category": "constraints",
+    "description": "Two new tables referencing each other. No order creates both with their keys: one key is added once both exist, and the reverse drops it before either table.",
+    "before": "CREATE TABLE unrelated (id int PRIMARY KEY);",
+    "after": "CREATE TABLE unrelated (id int PRIMARY KEY); CREATE TABLE a (id int PRIMARY KEY, b_id int); CREATE TABLE b (id int PRIMARY KEY, a_id int REFERENCES a (id) DEFERRABLE INITIALLY DEFERRED); ALTER TABLE a ADD CONSTRAINT a_b_fk FOREIGN KEY (b_id) REFERENCES b (id) DEFERRABLE INITIALLY DEFERRED;"
+  },
+  {
+    "id": "subpartitioned_partition_added",
+    "category": "partitions",
+    "description": "A partition that is partitioned in turn, with partitions of its own. Created as a plain partition, its own partitions have nowhere to go.",
+    "before": "CREATE TABLE h (id int, r text, s text) PARTITION BY LIST (r); CREATE TABLE h_us PARTITION OF h FOR VALUES IN ('us'); INSERT INTO h VALUES (1, 'us', 'a');",
+    "after": "CREATE TABLE h (id int, r text, s text) PARTITION BY LIST (r); CREATE TABLE h_us PARTITION OF h FOR VALUES IN ('us'); CREATE TABLE h_eu PARTITION OF h FOR VALUES IN ('eu') PARTITION BY LIST (s); CREATE TABLE h_eu_a PARTITION OF h_eu FOR VALUES IN ('a'); CREATE TABLE h_eu_b PARTITION OF h_eu FOR VALUES IN ('b'); INSERT INTO h VALUES (1, 'us', 'a');",
+    "preserve": [
+      "SELECT id, r, s FROM h ORDER BY id"
+    ]
+  },
+  {
+    "id": "partition_added_with_its_own_constraint_and_index",
+    "category": "partitions",
+    "description": "A new partition carrying a check and an index of its own, beside the parent's index it inherits. Declared against the parent alone, it arrives without them.",
+    "before": "CREATE TABLE h (id int, d date, n int) PARTITION BY RANGE (d); CREATE INDEX h_d ON h (d); CREATE TABLE h_2024 PARTITION OF h FOR VALUES FROM ('2024-01-01') TO ('2025-01-01'); INSERT INTO h VALUES (1, '2024-03-01', 2);",
+    "after": "CREATE TABLE h (id int, d date, n int) PARTITION BY RANGE (d); CREATE INDEX h_d ON h (d); CREATE TABLE h_2024 PARTITION OF h FOR VALUES FROM ('2024-01-01') TO ('2025-01-01'); CREATE TABLE h_2025 PARTITION OF h FOR VALUES FROM ('2025-01-01') TO ('2026-01-01'); ALTER TABLE h_2025 ADD CONSTRAINT h_2025_n CHECK (n > 0); CREATE INDEX h_2025_own ON h_2025 (n); INSERT INTO h VALUES (1, '2024-03-01', 2);",
+    "preserve": [
+      "SELECT id, d, n FROM h ORDER BY id"
+    ]
+  },
+  {
+    "id": "exclusion_constraint_needing_an_extension",
+    "category": "extensions",
+    "description": "An exclusion constraint whose operator class comes from btree_gist. The extension is installed first, and the reverse drops it after the constraint.",
+    "before": "CREATE TABLE bookings (id int PRIMARY KEY, room int, during tsrange);",
+    "after": "CREATE EXTENSION IF NOT EXISTS btree_gist; CREATE TABLE bookings (id int PRIMARY KEY, room int, during tsrange, cancelled boolean DEFAULT false, CONSTRAINT no_double_booking EXCLUDE USING gist (room WITH =, during WITH &&) WHERE (NOT cancelled));"
+  },
+  {
+    "id": "serial_default_dropped",
+    "category": "identity",
+    "description": "A serial column's default dropped. The sequence stays, still owned by the column; dropping it too loses its position.",
+    "before": "CREATE TABLE t (id serial PRIMARY KEY, v int); INSERT INTO t (v) VALUES (1), (2);",
+    "after": "CREATE TABLE t (id serial PRIMARY KEY, v int); INSERT INTO t (v) VALUES (1), (2); ALTER TABLE t ALTER id DROP DEFAULT;",
+    "preserve": [
+      "SELECT id, v FROM t ORDER BY id"
+    ]
+  },
+  {
+    "id": "quoted_identifiers",
+    "category": "names",
+    "description": "Names holding double quotes, spaces and capitals: a table, its columns, a check and a unique constraint, an index, a view, an enum type, a policy and comments. Each must be written with its quotes doubled; one written between plain quotes is a syntax error that fails the whole migration.",
+    "before": "CREATE TABLE \"Odd \"\"t\"\"\" (id int PRIMARY KEY); INSERT INTO \"Odd \"\"t\"\"\" (id) VALUES (1), (2);",
+    "after": "CREATE TYPE \"Mood \"\"m\"\"\" AS ENUM ('a', 'b');CREATE TABLE \"Odd \"\"t\"\"\" (id int PRIMARY KEY, \"Col \"\"c\"\"\" text CONSTRAINT \"chk \"\"x\"\"\" CHECK (\"Col \"\"c\"\"\" <> ''), \"m \"\"q\"\"\" \"Mood \"\"m\"\"\", CONSTRAINT \"uq \"\"u\"\"\" UNIQUE (\"Col \"\"c\"\"\")); INSERT INTO \"Odd \"\"t\"\"\" (id) VALUES (1), (2);CREATE INDEX \"ix \"\"i\"\"\" ON \"Odd \"\"t\"\"\" (\"m \"\"q\"\"\");CREATE VIEW \"v \"\"w\"\"\" AS SELECT id, \"Col \"\"c\"\"\" FROM \"Odd \"\"t\"\"\";ALTER TABLE \"Odd \"\"t\"\"\" ENABLE ROW LEVEL SECURITY;CREATE POLICY \"say \"\"hi\"\" there\" ON \"Odd \"\"t\"\"\" FOR SELECT USING (true);COMMENT ON POLICY \"say \"\"hi\"\" there\" ON \"Odd \"\"t\"\"\" IS 'a \"quoted\" note';COMMENT ON COLUMN \"Odd \"\"t\"\"\".\"Col \"\"c\"\"\" IS 'c';",
+    "preserve": [
+      "SELECT id FROM \"Odd \"\"t\"\"\" ORDER BY id"
+    ]
+  }
+]