okmodel 0.4.0 → 0.5.1

package/dist/shared/wq9n6pwr.js

@@ -0,0 +1,139 @@
+import {
+  tag
+} from "./cn0n68ft.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/filter-parse.ts
+var PARSED_OPS = ",eq,in,inList,notIn,lt,lte,gt,gte,between,startsWith,endsWith,contains,like,ilike,";
+var PARSED_FIX = "Use eq, in, notIn, lt, lte, gt, gte, between, startsWith, endsWith, contains, like, or ilike.";
+function parseQuery(allow, sort, query) {
+  if (typeof query !== "object" || query === null || Array.isArray(query)) {
+    throw new OkmError2("OKM1121", "filters parse expects an object of fields.");
+  }
+  for (const field of Object.keys(allow)) {
+    for (const op of allow[field] ?? []) {
+      if (PARSED_OPS.includes(`,${op},`))
+        continue;
+      throw new OkmError2("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: PARSED_FIX }
+      });
+    }
+  }
+  const whereParts = [];
+  let orderBy;
+  for (const key of Object.keys(query)) {
+    const value = query[key];
+    if (key === "sort" && typeof value === "string" && sort.includes(value)) {
+      orderBy = { [value]: "asc" };
+      continue;
+    }
+    if (!Object.hasOwn(allow, key)) {
+      throw new OkmError2("OKM1123", `Field ${key} is not in the allow list.`, {
+        fix: { summary: "Remove the field, or add it to filters({ allow })." }
+      });
+    }
+    const ops = allow[key] ?? [];
+    whereParts.push(...clauses(key, ops, value));
+  }
+  const where = combine(whereParts);
+  return orderBy === undefined ? { where } : { where, orderBy };
+}
+function clauses(field, ops, value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    if (!ops.includes("eq")) {
+      throw new OkmError2("OKM1120", `filters() cannot apply eq on ${field}.`, {
+        fix: { summary: "Add eq to that field, or send an object of allowed operators." }
+      });
+    }
+    return [{ [field]: value }];
+  }
+  const applied = [];
+  for (const op of Object.keys(value)) {
+    if (!Object.hasOwn(value, op))
+      continue;
+    if (!ops.includes(op) && !(op === "inList" && ops.includes("in"))) {
+      throw new OkmError2("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: "Send an operator that field's allow list names." }
+      });
+    }
+    applied.push(one(field, op, value[op]));
+  }
+  if (applied.length === 0) {
+    throw new OkmError2("OKM1120", `filters() cannot apply a value on ${field}.`, {
+      fix: { summary: "Send eq as a scalar, or an object of allowed operators." }
+    });
+  }
+  return applied;
+}
+function one(field, op, value) {
+  switch (op) {
+    case "eq":
+      return {
+        [field]: value !== null && typeof value === "object" ? tag("eq", value) : value
+      };
+    case "in":
+    case "inList":
+      return { [field]: tag("inList", list(value, op)) };
+    case "notIn":
+      return { [field]: tag("notIn", list(value, op)) };
+    case "lt":
+      return { [field]: tag("lt", value) };
+    case "lte":
+      return { [field]: tag("lte", value) };
+    case "gt":
+      return { [field]: tag("gt", value) };
+    case "gte":
+      return { [field]: tag("gte", value) };
+    case "between": {
+      if (!Array.isArray(value) || value.length !== 2) {
+        throw new OkmError2("OKM1120", `between on ${field} needs two bounds.`, {
+          fix: { summary: "Send between as [from, to]." }
+        });
+      }
+      return { [field]: tag("between", [value[0], value[1]]) };
+    }
+    case "startsWith":
+      return { [field]: tag("startsWith", text(value, op)) };
+    case "endsWith":
+      return { [field]: tag("endsWith", text(value, op)) };
+    case "contains":
+      return { [field]: tag("contains", value) };
+    case "like":
+      return { [field]: tag("like", text(value, op)) };
+    case "ilike":
+      return { [field]: tag("ilike", text(value, op)) };
+    default:
+      throw new OkmError2("OKM1120", `filters() cannot apply ${op} on ${field}.`, {
+        fix: { summary: "Use an operator parse applies." }
+      });
+  }
+}
+function combine(parts) {
+  const first = parts[0];
+  if (first === undefined)
+    return {};
+  if (parts.length === 1)
+    return first;
+  return tag("and", parts);
+}
+function list(value, op) {
+  if (!Array.isArray(value)) {
+    throw new OkmError2("OKM1120", `${op} needs an array.`, {
+      fix: { summary: "Send that operator an array of values." }
+    });
+  }
+  return value;
+}
+function text(value, op) {
+  if (typeof value !== "string") {
+    throw new OkmError2("OKM1120", `${op} needs a string.`, {
+      fix: { summary: "Send that operator a string." }
+    });
+  }
+  return value;
+}
+export {
+  parseQuery
+};

package/dist/shared/{7p2wbz7f.js → x72jb7ad.js}

@@ -6,7 +6,7 @@ import {
   acquireTimeout2,
   errorField2,
   mapDriverError2
-} from "./kyxb62mc.js";
+} from "./31vm914h.js";
 export {
   DriverError2 as DriverError,
   acquireTimeout2 as acquireTimeout,

package/dist/shared/{q795afwa.js → z2rnngj4.js}

@@ -11,7 +11,7 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
   if (code.artifact !== undefined) {
     const artifact = code.artifact;
     await loadOnce(`text\x00${artifact.hash}`, async () => {
-      const { loadTrustedCatalog } = await import("./6693j9rs.js");
+      const { loadTrustedCatalog } = await import("./5fqx9yh4.js");
       loadTrustedCatalog(artifact.text, artifact.hash);
     });
   } else if (code.fromFile) {
@@ -25,7 +25,7 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
           }
         });
       }
-      const { loadTrustedCatalog } = await import("./6693j9rs.js");
+      const { loadTrustedCatalog } = await import("./5fqx9yh4.js");
       loadTrustedCatalog(text, code.hash);
     });
   }
@@ -39,7 +39,7 @@ async function codeHash(schema, source) {
   const listed = await readHashFile(source.catalogDir);
   if (listed !== undefined)
     return { hash: listed, fromFile: true };
-  const { catalogHash } = await import("./6693j9rs.js");
+  const { catalogHash } = await import("./5fqx9yh4.js");
   return { hash: catalogHash(schemaCatalog(schema)), fromFile: false };
 }
 function schemaCatalog(schema) {

package/dist/shared/{sr5ms7b3.js → zqrnhwsq.js}

@@ -1,9 +1,9 @@
 import {
   withHttp
-} from "./kkzwp3d2.js";
+} from "./hf22e0wt.js";
 import {
   decodeResult
-} from "./xrfnq5k8.js";
+} from "./gbtcc2d7.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -17,7 +17,7 @@ async function* streamRows(session, call, prepare, log) {
     })));
   }
   const { plan, params } = await prepare();
-  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./edwqqryd.js")).decodeIncluded;
+  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./nkaxvt9q.js")).decodeIncluded;
   for await (const chunk of session.pool.stream(plan.text, params)) {
     const decoded = decode(plan, chunk, call.table);
     if (!Array.isArray(decoded))

package/dist/tooling/cli.js

@@ -1,6 +1,6 @@
-import"../shared/8jb4ymh2.js";
+import"../shared/8bwbwy8h.js";
 import"../shared/n442h54c.js";
-import"../shared/wqem4jed.js";
+import"../shared/krxx77g0.js";
 import {
   formatFindings,
   hasError,
@@ -9,9 +9,9 @@ import {
   generateProject,
   planProject,
   checkProject
-} from "../shared/q6zsyh31.js";
-import"../shared/n5y9zyj1.js";
-import"../shared/41kv2xdm.js";
+} from "../shared/qv2ydck9.js";
+import"../shared/ga3sfy93.js";
+import"../shared/8xsbagad.js";
 import {
   OkmError2
 } from "../shared/52szzakm.js";
@@ -22,14 +22,28 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/tooling/migrate/commands.ts
-function formatFailure(error) {
-  return `${error.code}: ${error.message}
-${error.fix.summary}
+function formatFailure(error, verbose = false) {
+  const mapped = OkmError2.from(error);
+  let text = `error ${mapped.code}: ${mapped.message}
+${mapped.fix.summary}
 `;
+  if (verbose && error instanceof Error && error.stack !== undefined) {
+    text += `${error.stack}
+`;
+  }
+  return text;
 }
 async function run(argv, io) {
   const cwd = io?.cwd ?? process.cwd();
   const stdout = io?.stdout ?? ((text) => process.stdout.write(text));
+  if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+    stdout(commandsTable());
+    return;
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    stdout(commandHelp(argv.filter((arg) => arg !== "--help" && arg !== "-h")));
+    return;
+  }
   const [command, ...rest] = argv;
   if (command === "build") {
     const directory = await buildProject(cwd);
@@ -57,12 +71,12 @@ async function run(argv, io) {
     return;
   }
   if (command === "dev") {
-    const { devProject } = await import("../shared/yjw02enp.js");
+    const { devProject } = await import("../shared/sdc7r2ww.js");
     stdout(await devProject(cwd));
     return;
   }
   if (command === "push") {
-    const { pushProject } = await import("../shared/kj680nxv.js");
+    const { pushProject } = await import("../shared/q58y17hy.js");
     stdout(await pushProject(cwd, invoke(splitFlags(rest))));
     return;
   }
@@ -81,17 +95,17 @@ async function run(argv, io) {
       return;
     }
     if (sub === "apply") {
-      const { applyProject } = await import("../shared/kj680nxv.js");
+      const { applyProject } = await import("../shared/q58y17hy.js");
       stdout(await applyProject(cwd, invoke(parsed), stdout));
       return;
     }
     if (sub === "status") {
-      const { statusProject } = await import("../shared/c5g81ngb.js");
+      const { statusProject } = await import("../shared/6mnp99hx.js");
       stdout(await statusProject(cwd, invoke(parsed)));
       return;
     }
     if (sub === "check") {
-      const { checkMigrations } = await import("../shared/2321avmn.js");
+      const { checkMigrations } = await import("../shared/7zwwyh0v.js");
       const provision = parsed.flags.includes("--provision") || rest.slice(1).includes("--provision");
       stdout(await checkMigrations(cwd, invoke(parsed), { provision }));
       return;
@@ -104,13 +118,13 @@ async function run(argv, io) {
         fix: { summary: "Pass okm seed <file>." }
       });
     }
-    const { seedProject } = await import("../shared/ady1ms74.js");
+    const { seedProject } = await import("../shared/2pqx26h8.js");
     stdout(await seedProject(cwd, parsed.name, invoke(parsed)));
     return;
   }
   if (command === "doctor") {
     const parsed = splitFlags(rest);
-    const { doctorProject } = await import("../shared/84ptn35q.js");
+    const { doctorProject } = await import("../shared/ps7a6h14.js");
     stdout(await doctorProject(cwd, parsed.name, invoke(parsed)));
     return;
   }
@@ -122,7 +136,7 @@ async function run(argv, io) {
       });
     }
     if (sub === "list" || sub === "check") {
-      const { extProject } = await import("../shared/tny2t3sm.js");
+      const { extProject } = await import("../shared/janx09m5.js");
       stdout(await extProject(cwd, sub, invoke(splitFlags(rest.slice(1)))));
       return;
     }
@@ -210,6 +224,42 @@ function splitFlags(args) {
     statementTimeoutMs
   };
 }
+var COMMANDS = [
+  ["build", "Write the schema build."],
+  ["check", "Lint the schema and compare it with one target."],
+  ["dev", "Watch the schema and reload."],
+  ["doctor [code]", "Print a target report, or one error code."],
+  ["ext list", "List extensions the server can install."],
+  ["ext check", "Compare declared extensions with the server."],
+  ["generate [name]", "Write the next migration."],
+  ["migrate plan <name>", "Print the plan and its lock estimates."],
+  ["migrate apply", "Apply pending migrations."],
+  ["migrate status", "Print whether the target is current."],
+  ["migrate check", "Replay migration history in a scratch schema."],
+  ["push", "Apply the schema diff to one target."],
+  ["seed <file>", "Run a seed file on one target."]
+];
+function commandsTable() {
+  const lines = ["okm <command>", ""];
+  for (const [name, summary] of COMMANDS)
+    lines.push(`  ${name.padEnd(24)} ${summary}`);
+  lines.push("", "okm <command> --help prints that command.", "");
+  return `${lines.join(`
+`)}
+`;
+}
+function commandHelp(argv) {
+  const key = argv.join(" ");
+  const found = COMMANDS.find(([name]) => name === key || name.startsWith(`${key} `));
+  if (found === undefined) {
+    return `Unknown command ${key}.
+
+${commandsTable()}`;
+  }
+  return `${found[0]}
+${found[1]}
+`;
+}
 function numberFlag(flag, value) {
   const parsed = value === undefined ? Number.NaN : Number(value);
   if (!Number.isFinite(parsed) || parsed < 0) {
@@ -226,16 +276,13 @@ var packageJsonPath = join(here, "..", "..", "package.json");
 if (process.argv.includes("--version")) {
   process.stdout.write(`${readPackageVersion(packageJsonPath)}
 `);
-} else if (process.argv.length > 2) {
+} else {
   try {
     await run(process.argv.slice(2));
   } catch (error) {
-    if (error instanceof OkmError2) {
-      process.stderr.write(formatFailure(error));
-      process.exitCode = 1;
-    } else {
-      throw error;
-    }
+    const verbose = process.argv.includes("--verbose") || process.env.OKM_DEBUG === "1";
+    process.stderr.write(formatFailure(error, verbose));
+    process.exitCode = 1;
   }
 }
 function readPackageVersion(path) {

package/dist/tooling/migrate/apply.d.ts

@@ -90,6 +90,8 @@ export type ApplyRequest = {
 export type ApplyReport = {
     readonly target: string;
     readonly applied: readonly string[];
+    /** Migrations whose stored hash moved from the pre-D208 hash to the startup hash. */
+    readonly restamped?: readonly string[];
     /** Set when the runner issued `SET ROLE` at session start. */
     readonly setRole?: string;
 };

package/dist/tooling/migrate/commands.d.ts

@@ -4,7 +4,6 @@
  * The bin wrapper imports {@link run}. Importing this module does not parse
  * `process.argv`.
  */
-import { OkmError } from "../../contracts/error.js";
 /** Where a command reads the project and writes its text. */
 export type CommandIo = {
     readonly cwd?: string;
@@ -18,7 +17,7 @@ export type CommandIo = {
  * @param error - Failure from a command
  * @returns The stderr text, including the trailing newline
  */
-export declare function formatFailure(error: OkmError): string;
+export declare function formatFailure(error: unknown, verbose?: boolean): string;
 /**
  * Runs one `okm` invocation.
  *

package/dist/tooling/migrate/drift.d.ts

@@ -18,7 +18,7 @@ import type { RolesInput } from "../../dialects/pg/role/index.js";
  * @param author - Schema catalog, including roles when the config names them
  * @param roles - `defineConfig({ roles })`, when set
  */
-export declare function assertAuthorDrift(url: string, author: Catalog, roles?: RolesInput): Promise<void>;
+export declare function assertAuthorDrift(url: string, author: Catalog, roles?: RolesInput, allowPooler?: boolean): Promise<void>;
 /**
  * Turns a postgres.js handle into the query shape introspection uses.
  *

package/dist/tooling/migrate/estimate.d.ts

@@ -40,7 +40,20 @@ export declare function readRowEstimates(url: string, schema: string, tables: re
  * @param estimates - `reltuples` for tables that exist on the target
  * @returns The text after `-- lock: `
  */
-export declare function annotateLock(step: PlanStep, estimates: ReadonlyMap<string, RowEstimate>): string;
+export declare function annotateLock(step: PlanStep, estimates: ReadonlyMap<string, RowEstimate>, aliases?: ReadonlyMap<string, string>): string;
+/**
+ * Maps a rename destination to the table that still has `reltuples`.
+ *
+ * The rename statement names the old table. Later steps name the new one,
+ * which is not in `pg_class` yet.
+ *
+ * @param steps - Plan steps
+ * @returns New name to old name
+ */
+export declare function renameAliases(steps: readonly {
+    readonly kind?: string;
+    readonly sql: string;
+}[]): ReadonlyMap<string, string>;
 /**
  * Compact phrase for one estimate.
  *

package/dist/tooling/migrate/files.d.ts

@@ -7,6 +7,13 @@ import { type PlanStep } from "./plan.js";
 export type StoredMigration = {
     readonly id: string;
     readonly catalogHash: string;
+    /**
+     * The hash written before D208, which counted roles and grants.
+     *
+     * Set only when the catalog has them. Apply moves a stored copy of it to
+     * {@link StoredMigration.catalogHash}.
+     */
+    readonly legacyHash?: string;
     readonly steps: readonly PlanStep[];
 };
 /**

package/dist/tooling/migrate/index.js

@@ -1,23 +1,26 @@
-import"../../shared/wqem4jed.js";
-import"../../shared/8jb4ymh2.js";
+import"../../shared/krxx77g0.js";
+import"../../shared/8bwbwy8h.js";
 import"../../shared/n442h54c.js";
 import {
   applyTarget2,
   backfillTiming2
-} from "../../shared/s4mb6a4b.js";
+} from "../../shared/cctw17hj.js";
 import {
   loadMigrations,
   loadHeadSnapshot,
   readReference
-} from "../../shared/7nk68fj8.js";
+} from "../../shared/gde73es6.js";
+import"../../shared/szm0cksa.js";
+import"../../shared/fancm5pt.js";
 import {
-  assertTargetPolicy,
-  selectTarget,
   loadBuiltSchema,
   loadConfig
-} from "../../shared/q6zsyh31.js";
-import"../../shared/n5y9zyj1.js";
-import"../../shared/41kv2xdm.js";
+} from "../../shared/qv2ydck9.js";
+import {
+  assertTargetPolicy,
+  selectTarget
+} from "../../shared/ga3sfy93.js";
+import"../../shared/8xsbagad.js";
 import {
   OkmError2
 } from "../../shared/52szzakm.js";

package/dist/tooling/migrate/lint.d.ts

@@ -2,14 +2,14 @@
  * Runs the migration linter.
  *
  * The linter reads a plan and the two catalogs. It does not connect.
- * An override is a `-- okm-allow` line on the statement. It silences only
- * the code it names, and only with a reason.
+ * An override is a `-- okm-allow` line on the step. It silences that code
+ * on every statement of the step, and only with a reason.
  */
 import type { Catalog } from "../../contracts/catalog/types.js";
 import { OkmError } from "../../contracts/error.js";
 import { type LintSeverity } from "./lint-rules.js";
 import { type MigrationPlan } from "./plan.js";
-/** One finding. `place` is `step N` or `table.column`, optionally prefixed with the file. */
+/** One finding. `place` is `step N`, `step N statement M`, or `table.column`. */
 export type Finding = {
     readonly severity: LintSeverity;
     readonly code: string;

package/dist/tooling/migrate/plan.d.ts

@@ -70,10 +70,10 @@ export type PlanStep = {
      */
     readonly behavior?: "change";
     /**
-     * `-- okm-allow` lines directly above the statement.
+     * `-- okm-allow` lines on the step.
      *
-     * A reason silences that code only. An empty reason, or a code the
-     * statement did not trigger, is OKM1510 and silences nothing.
+     * A reason silences that code on every statement of the step. An empty
+     * reason, or a code no statement triggered, is OKM1510 and silences nothing.
      */
     readonly allows?: readonly StepAllow[];
 };
@@ -128,6 +128,10 @@ export declare function formatPlan(plan: MigrationPlan, lockText?: (step: PlanSt
 /**
  * Reads a plan written by {@link formatPlan}.
  *
+ * A blank line ends a step. A blank line inside a quote, a dollar quote, or
+ * a block comment stays in that step, and so does a `--` line while the
+ * quote is still open.
+ *
  * @param text - SQL file text
  * @returns The plan. The header class is kept when the file has no steps
  */

package/dist/tooling/migrate/policy.d.ts

@@ -56,6 +56,17 @@ export declare function assertTargetAlias(targets: readonly TargetRecord[]): voi
  * @param allowPooler - The invocation opted in
  */
 export declare function assertDirectConnection(url: string, allowPooler: boolean): void;
+/**
+ * Refuses a session whose backend pid changes between two statements.
+ *
+ * The two reads are separate round trips and are not wrapped in a
+ * transaction. A transaction-mode pooler can hand back a different backend
+ * for the second one. `--allow-pooler` skips the probe.
+ *
+ * @param readPid - Reads `pg_backend_pid()` on the session under test
+ * @param allowPooler - The invocation opted in
+ */
+export declare function assertStableBackend(readPid: () => Promise<string>, allowPooler: boolean): Promise<void>;
 /**
  * Lists configured targets.
  *

package/dist/tooling/migrate/sql-lex.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Splits one migration step into statements.
+ *
+ * Comments are removed. A semicolon splits only at the top level.
+ * `standard_conforming_strings` is on: a plain `'...'` ends on a single
+ * quote, and `''` is one quote inside it. `E'...'` still treats a backslash
+ * as an escape. A dollar quote runs until the same tag; a different tag
+ * inside it is text, so `$outer$ ... $inner$ ... $inner$ ... $outer$` stays
+ * one span. An unterminated string, quoted identifier, block comment, or
+ * dollar quote is one opaque tail. This function does not throw.
+ */
+/** Statements of `sql`, comments removed, with no trailing semicolon. */
+export declare function sqlStatements(sql: string): readonly string[];
+/**
+ * Whether `sql` still has an open quote or block comment.
+ *
+ * A line comment does not count: it ends at the newline or at the end.
+ *
+ * @param sql - Step text accumulated so far
+ * @returns `true` when a later blank line is still inside that quote
+ */
+export declare function sqlQuoteOpen(sql: string): boolean;

package/dist/tooling/testing/factories.d.ts

@@ -114,4 +114,14 @@ export declare function bindFactories(host: FactoryHost, definitions: Readonly<R
  * @returns The inserted row
  */
 export declare function insertRow(host: FactoryHost, table: string, overrides: Readonly<Record<string, unknown>> | undefined, children: Readonly<Record<string, number>> | undefined, inherited: string | undefined): Promise<Record<string, unknown>>;
+/**
+ * Drops a cached factory row.
+ *
+ * `isolation()` deletes the row it inserted. A later table must not reuse that id.
+ *
+ * @param host - The open harness
+ * @param table - Table name
+ * @param tenant - Tenant scope, when the table is tenanted
+ */
+export declare function forgetCached(host: FactoryHost, table: string, tenant: string | undefined): void;
 export {};

package/dist/tooling/testing/facts.d.ts

@@ -56,6 +56,9 @@ export declare const tenantProbe = "00000000-0000-4000-8000-000000000001";
 /**
  * Reads every table in declaration order.
  *
+ * Views and materialized views are in the query model too. They have no rows
+ * of their own to insert, so they are left out.
+ *
  * @param schema - Compiled schema
  * @returns One facts object per table
  */

package/dist/tooling/testing/index.js

@@ -1,8 +1,8 @@
 import {
   testing2
-} from "../../shared/ygem90rn.js";
-import"../../shared/41kv2xdm.js";
-import"../../shared/8jb4ymh2.js";
+} from "../../shared/v36c5g6p.js";
+import"../../shared/8xsbagad.js";
+import"../../shared/8bwbwy8h.js";
 export {
   testing2 as testing
 };

package/dist/tooling/testing/isolation.d.ts

@@ -1,9 +1,10 @@
 /**
  * Cross-tenant isolation check.
  *
- * For every tenant table, insert one row as tenant B and run the basic reads
- * and writes as tenant A. A returned row, a count above zero, or an update or
- * delete that touches a row is a leak. Global tables are skipped and listed.
+ * For every tenant table, insert one row as tenant B and run the reads and
+ * writes as tenant A against that row's key. A returned row, or an update or
+ * delete that touches it, is a leak. The row is deleted afterwards. Global
+ * tables are skipped and listed.
  * Column tenancy is the strategy this version has. A table is tenant when its
  * predicate says so (D199).
  */