@coradb/coradb-sqlsyntaxchecker-wasm 0.3.3

package/schema.json

@@ -0,0 +1,127 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "coradb-schema-v1.json",
+  "title": "CoraDB schema document, version 1",
+  "description": "A CoraDB database's schema, read from its catalog: objects, their columns, keys, indexes and comments, stored procedures and functions, serials and synonyms. Nothing from the tables' data. Any optional part may be missing: a missing list or field means 'not known', never 'there are none'.",
+  "type": "object",
+  "required": ["format", "version", "objects"],
+  "properties": {
+    "format": { "const": "coradb-schema" },
+    "version": { "const": 1 },
+    "database": { "type": "string" },
+    "objects": { "type": "array", "items": { "$ref": "#/$defs/object" } },
+    "procedures": { "type": "array", "items": { "$ref": "#/$defs/procedure" } },
+    "serials": { "type": "array", "items": { "$ref": "#/$defs/serial" } },
+    "synonyms": { "type": "array", "items": { "$ref": "#/$defs/synonym" } }
+  },
+  "$defs": {
+    "comment": { "type": ["string", "null"] },
+    "names": { "type": "array", "items": { "type": "string" } },
+    "object": {
+      "type": "object",
+      "required": ["name", "kind"],
+      "properties": {
+        "name": { "type": "string" },
+        "owner": { "type": "string" },
+        "kind": { "enum": ["table", "view", "node", "edge"] },
+        "comment": { "$ref": "#/$defs/comment" },
+        "under": { "$ref": "#/$defs/names", "description": "Parent classes (CREATE ... UNDER), as owner.name or name; their columns are inherited." },
+        "columns": { "type": "array", "items": { "$ref": "#/$defs/column" }, "description": "In table order." },
+        "primaryKey": { "$ref": "#/$defs/names" },
+        "unique": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["name", "columns"],
+            "properties": { "name": { "type": "string" }, "columns": { "$ref": "#/$defs/names" } }
+          }
+        },
+        "foreignKeys": { "type": "array", "items": { "$ref": "#/$defs/foreignKey" } },
+        "indexes": { "type": "array", "items": { "$ref": "#/$defs/index" } },
+        "definition": { "type": "string", "description": "Views only: the SELECT that defines it." }
+      }
+    },
+    "column": {
+      "type": "object",
+      "required": ["name", "type"],
+      "properties": {
+        "name": { "type": "string" },
+        "type": { "type": "string", "description": "As CoraDB names it: INTEGER, VARCHAR, NUMERIC, DATETIME, ENUM, SET..." },
+        "length": { "type": "integer" },
+        "precision": { "type": "integer" },
+        "scale": { "type": "integer" },
+        "values": { "$ref": "#/$defs/names", "description": "ENUM: the values it allows." },
+        "elementType": { "type": "string", "description": "SET, MULTISET, LIST: the type of the elements." },
+        "nullable": { "type": "boolean" },
+        "default": { "type": ["string", "null"], "description": "The default as SQL text, e.g. 'RO' or SYS_DATETIME." },
+        "autoIncrement": { "type": "boolean" },
+        "comment": { "$ref": "#/$defs/comment" }
+      }
+    },
+    "foreignKey": {
+      "type": "object",
+      "required": ["name", "columns", "references", "refColumns"],
+      "properties": {
+        "name": { "type": "string" },
+        "columns": { "$ref": "#/$defs/names" },
+        "references": { "type": "string", "description": "owner.name, or name when the owner is not known." },
+        "refColumns": { "$ref": "#/$defs/names" },
+        "onDelete": { "type": "string" },
+        "onUpdate": { "type": "string" }
+      }
+    },
+    "index": {
+      "type": "object",
+      "required": ["name", "columns", "unique"],
+      "properties": {
+        "name": { "type": "string" },
+        "columns": { "$ref": "#/$defs/names" },
+        "unique": { "type": "boolean" },
+        "comment": { "$ref": "#/$defs/comment" }
+      }
+    },
+    "procedure": {
+      "type": "object",
+      "required": ["name", "kind"],
+      "properties": {
+        "name": { "type": "string" },
+        "owner": { "type": "string" },
+        "kind": { "enum": ["procedure", "function"] },
+        "returns": { "type": "string", "description": "Functions only." },
+        "comment": { "$ref": "#/$defs/comment" },
+        "params": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["name", "type", "mode"],
+            "properties": {
+              "name": { "type": "string" },
+              "type": { "type": "string" },
+              "mode": { "enum": ["IN", "OUT", "INOUT"] },
+              "comment": { "$ref": "#/$defs/comment" }
+            }
+          }
+        }
+      }
+    },
+    "serial": {
+      "type": "object",
+      "required": ["name"],
+      "properties": {
+        "name": { "type": "string" },
+        "owner": { "type": "string" },
+        "comment": { "$ref": "#/$defs/comment" }
+      }
+    },
+    "synonym": {
+      "type": "object",
+      "required": ["name", "target"],
+      "properties": {
+        "name": { "type": "string" },
+        "owner": { "type": "string" },
+        "target": { "type": "string", "description": "owner.name of what it stands for." },
+        "comment": { "$ref": "#/$defs/comment" }
+      }
+    }
+  }
+}

package/tools/coradbSchema.ts

@@ -0,0 +1,483 @@
+/**
+ * Read a CoraDB database's schema from its catalog, as a CoraDB schema
+ * document (`"format": "coradb-schema"`, version 1): its tables, views, node
+ * and edge classes with their columns, keys, indexes and comments, its stored
+ * procedures and functions, serials and synonyms. Nothing is read from the
+ * tables themselves: no rows, no counts, no sample values.
+ *
+ * Self-contained, to be copied into other projects: it needs only a way to run
+ * a query and get its rows back (`QueryRows`), so it works with any driver.
+ *
+ *   const schema = await readCoraDbSchema(async (sql) => rowsOf(await conn.query(sql)));
+ *
+ * Catalogs differ between engine builds — a column one has, another lacks —
+ * so every read tries the fullest form first and falls back to plainer ones,
+ * and a part of the catalog that cannot be read is left out of the document
+ * rather than failing it: a missing list means "not known", never "none".
+ */
+
+// --- the format ------------------------------------------------------------------
+
+export interface CoraDbSchema {
+  format: 'coradb-schema';
+  version: 1;
+  database?: string;
+  objects: SchemaObject[];
+  procedures?: SchemaProcedure[];
+  serials?: SchemaSerial[];
+  synonyms?: SchemaSynonym[];
+}
+
+export type SchemaObjectKind = 'table' | 'view' | 'node' | 'edge';
+
+export interface SchemaObject {
+  name: string;
+  owner?: string;
+  kind: SchemaObjectKind;
+  comment?: string | null;
+  /** Parent classes (CREATE … UNDER), as `owner.name` or `name`. */
+  under?: string[];
+  /** In table order. Missing when the catalog could not say. */
+  columns?: SchemaColumn[];
+  primaryKey?: string[];
+  unique?: { name: string; columns: string[] }[];
+  foreignKeys?: SchemaForeignKey[];
+  /** Secondary indexes, unique ones included; not the primary or foreign keys. */
+  indexes?: SchemaIndex[];
+  /** Views only: the SELECT that defines it. */
+  definition?: string;
+}
+
+export interface SchemaColumn {
+  name: string;
+  type: string;
+  length?: number;
+  precision?: number;
+  scale?: number;
+  values?: string[];
+  elementType?: string;
+  nullable?: boolean;
+  default?: string | null;
+  autoIncrement?: boolean;
+  comment?: string | null;
+}
+
+export interface SchemaForeignKey {
+  name: string;
+  columns: string[];
+  references: string;
+  refColumns: string[];
+  onDelete?: string;
+  onUpdate?: string;
+}
+
+export interface SchemaIndex {
+  name: string;
+  columns: string[];
+  unique: boolean;
+  comment?: string | null;
+}
+
+export interface SchemaProcedure {
+  name: string;
+  owner?: string;
+  kind: 'procedure' | 'function';
+  returns?: string;
+  comment?: string | null;
+  params?: SchemaParam[];
+}
+
+export interface SchemaParam {
+  name: string;
+  type: string;
+  mode: 'IN' | 'OUT' | 'INOUT';
+  comment?: string | null;
+}
+
+export interface SchemaSerial {
+  name: string;
+  owner?: string;
+  comment?: string | null;
+}
+
+export interface SchemaSynonym {
+  name: string;
+  owner?: string;
+  target: string;
+  comment?: string | null;
+}
+
+// --- reading it ----------------------------------------------------------------------
+
+/** Run one query and return its rows, keyed by lower-cased column name. */
+export type QueryRows = (sql: string) => Promise<Record<string, unknown>[]>;
+
+const str = (v: unknown): string => (v === null || v === undefined ? '' : String(v)).trim();
+const yes = (v: unknown): boolean => str(v).toUpperCase() === 'YES';
+const opt = (v: unknown): string | null => (str(v) === '' ? null : str(v));
+const num = (v: unknown): number | undefined => {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : undefined;
+};
+/** `[name]`, for a statement the catalog is asked with. */
+const bracket = (name: string): string => `[${name.replace(/]/g, ']]')}]`;
+const lower = (s: string): string => s.toLowerCase();
+/** The key one class's rows are filed under: owner (when known) and name. */
+const keyOf = (owner: string, name: string): string => `${lower(owner)}\u0000${lower(name)}`;
+
+/** The first of these queries the catalog accepts; null when it accepts none. */
+async function firstOf(query: QueryRows, sqls: string[]): Promise<Record<string, unknown>[] | null> {
+  for (const sql of sqls) {
+    try {
+      return await query(sql);
+    } catch {
+      // A column this build does not have: try the next, plainer form.
+    }
+  }
+  return null;
+}
+
+/** The engine's largest string: a VARCHAR declared without a length has it. */
+const UNBOUNDED = 1073741823;
+
+/** A column's type as CoraDB names it, with the sizes that matter for it. */
+function columnType(
+  dataType: string,
+  prec: number | undefined,
+  scale: number | undefined,
+): Pick<SchemaColumn, 'type' | 'length' | 'precision' | 'scale'> {
+  const t = dataType.toUpperCase();
+  const type = t === 'STRING' ? 'VARCHAR' : t === 'SEQUENCE' ? 'LIST' : t;
+  if (/^(NUMERIC|DECIMAL)$/.test(type)) {
+    return { type, ...(prec ? { precision: prec } : {}), ...(scale !== undefined ? { scale } : {}) };
+  }
+  if (/CHAR|BIT/.test(type) && prec && prec > 0 && prec < UNBOUNDED) return { type, length: prec };
+  return { type };
+}
+
+/** ENUM('a','b') → ['a', 'b']. */
+function enumValues(type: string): string[] | undefined {
+  const m = /^\s*ENUM\s*\(([\s\S]*)\)\s*$/i.exec(type);
+  if (!m) return undefined;
+  return [...m[1].matchAll(/'((?:[^']|'')*)'/g)].map((v) => v[1].replace(/''/g, "'"));
+}
+
+const IDENT = String.raw`(?:\[[^\]]+\]|"[^"]+"|` + '`[^`]+`' + String.raw`|[A-Za-z_#][\w#$]*)`;
+const unquote = (s: string): string => (/^[[`"]/.test(s) ? s.slice(1, -1) : s);
+const nameOf = (s: string): string => [...s.matchAll(new RegExp(IDENT, 'g'))].map((m) => unquote(m[0])).join('.');
+
+/** The FOREIGN KEY clauses of a CREATE TABLE statement. */
+export function parseForeignKeys(ddl: string): SchemaForeignKey[] {
+  const out: SchemaForeignKey[] = [];
+  const re = new RegExp(
+    String.raw`(?:CONSTRAINT\s+(${IDENT})\s+)?FOREIGN\s+KEY\s*(?:${IDENT}\s*)?\(([^)]*)\)\s*` +
+      String.raw`REFERENCES\s+(${IDENT}(?:\s*\.\s*${IDENT})?)\s*\(([^)]*)\)` +
+      String.raw`((?:\s+ON\s+(?:DELETE|UPDATE)\s+(?:NO\s+ACTION|SET\s+NULL|CASCADE|RESTRICT))*)`,
+    'gi',
+  );
+  const list = (s: string) =>
+    s
+      .split(',')
+      .map((c) => unquote(c.trim().replace(/\s+(asc|desc)$/i, '')))
+      .filter(Boolean);
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(ddl)) !== null) {
+    const actions = m[5] ?? '';
+    const onDelete = /ON\s+DELETE\s+(NO\s+ACTION|SET\s+NULL|CASCADE|RESTRICT)/i.exec(actions)?.[1];
+    const onUpdate = /ON\s+UPDATE\s+(NO\s+ACTION|SET\s+NULL|CASCADE|RESTRICT)/i.exec(actions)?.[1];
+    out.push({
+      name: m[1] ? unquote(m[1]) : `fk_${out.length + 1}`,
+      columns: list(m[2]),
+      references: nameOf(m[3]),
+      refColumns: list(m[4]),
+      ...(onDelete ? { onDelete: onDelete.toUpperCase().replace(/\s+/g, ' ') } : {}),
+      ...(onUpdate ? { onUpdate: onUpdate.toUpperCase().replace(/\s+/g, ' ') } : {}),
+    });
+  }
+  return out;
+}
+
+const KINDS: Record<string, SchemaObjectKind> = { CLASS: 'table', VCLASS: 'view', VERTEX: 'node', EDGE: 'edge' };
+
+/**
+ * The whole schema of the database the query runs against: every object that
+ * is not part of the engine's own catalog, as the connection's user can see it.
+ */
+export async function readCoraDbSchema(query: QueryRows): Promise<CoraDbSchema> {
+  const schema: CoraDbSchema = { format: 'coradb-schema', version: 1, objects: [] };
+
+  const db = await firstOf(query, ['select database() as name from db_root']);
+  if (db?.[0] && str(db[0].name)) schema.database = str(db[0].name);
+
+  // --- objects ---
+  const classes =
+    (await firstOf(query, [
+      "select class_name, owner_name, class_type, comment from db_class where is_system_class = 'NO' order by class_name",
+      "select class_name, owner_name, class_type from db_class where is_system_class = 'NO' order by class_name",
+      "select class_name, class_type from db_class where is_system_class = 'NO' order by class_name",
+    ])) ?? [];
+  // A partitioned table's partitions are classes of their own; they are the table.
+  const partitions = new Set(
+    ((await firstOf(query, ['select partition_class_name from db_partition'])) ?? []).map((r) =>
+      lower(str(r.partition_class_name)),
+    ),
+  );
+  const byKey = new Map<string, SchemaObject>();
+  const byName = new Map<string, SchemaObject[]>();
+  for (const r of classes) {
+    const name = str(r.class_name);
+    const kind = KINDS[str(r.class_type).toUpperCase()];
+    if (!name || !kind || partitions.has(lower(name))) continue;
+    const owner = str(r.owner_name);
+    const o: SchemaObject = { name, ...(owner ? { owner } : {}), kind, columns: [] as SchemaColumn[] };
+    if ('comment' in r) o.comment = opt(r.comment);
+    schema.objects.push(o);
+    byKey.set(keyOf(owner, name), o);
+    byName.set(lower(name), [...(byName.get(lower(name)) ?? []), o]);
+  }
+  /** The object a catalog row is about: by owner and name where the row has an owner. */
+  const objectFor = (r: Record<string, unknown>, nameCol = 'class_name', ownerCol = 'owner_name') => {
+    const name = str(r[nameCol]);
+    if (ownerCol in r && str(r[ownerCol])) return byKey.get(keyOf(str(r[ownerCol]), name)) ?? null;
+    const all = byName.get(lower(name)) ?? [];
+    return all.length > 0 ? all : null;
+  };
+  const eachObject = (found: SchemaObject | SchemaObject[] | null, fn: (o: SchemaObject) => void) => {
+    if (!found) return;
+    for (const o of Array.isArray(found) ? found : [found]) fn(o);
+  };
+
+  // --- columns ---
+  const attrs = await firstOf(query, [
+    'select class_name, owner_name, attr_name, attr_type, data_type, prec, scale, is_nullable, default_value, comment, def_order from db_attribute order by class_name, def_order',
+    'select class_name, attr_name, attr_type, data_type, prec, scale, is_nullable, default_value, comment, def_order from db_attribute order by class_name, def_order',
+    'select class_name, attr_name, attr_type, data_type, prec, scale, is_nullable, default_value, def_order from db_attribute order by class_name, def_order',
+    'select class_name, attr_name, data_type, prec, scale, def_order from db_attribute order by class_name, def_order',
+  ]);
+  const enumTables = new Set<SchemaObject>();
+  const collections: { o: SchemaObject; c: SchemaColumn }[] = [];
+  for (const r of attrs ?? []) {
+    // A CLASS attribute belongs to the class, not to its rows.
+    if (str(r.attr_type).toUpperCase() === 'CLASS') continue;
+    eachObject(objectFor(r), (o) => {
+      const c: SchemaColumn = { name: str(r.attr_name), ...columnType(str(r.data_type), num(r.prec), num(r.scale)) };
+      if ('is_nullable' in r) c.nullable = yes(r.is_nullable);
+      if ('default_value' in r) c.default = opt(r.default_value);
+      if ('comment' in r) c.comment = opt(r.comment);
+      if (c.type === 'ENUM') enumTables.add(o);
+      if (/^(SET|MULTISET|LIST)$/.test(c.type)) collections.push({ o, c });
+      o.columns?.push(c);
+    });
+  }
+  if (attrs === null) {
+    // Not even the plainest form: columns not known for any object.
+    for (const o of schema.objects) delete o.columns;
+  }
+
+  // The values an ENUM allows are only in the column's full type.
+  for (const o of enumTables) {
+    // With the owner where there is one: two owners may have a table of the same name.
+    const rows = await firstOf(query, [
+      ...(o.owner ? [`show columns from ${bracket(o.owner)}.${bracket(o.name)}`] : []),
+      `show columns from ${bracket(o.name)}`,
+    ]);
+    for (const r of rows ?? []) {
+      const c = o.columns?.find((x) => lower(x.name) === lower(str(r.field)));
+      const values = c ? enumValues(str(r.type)) : undefined;
+      if (c && values) c.values = values;
+    }
+  }
+  // What a SET, MULTISET or LIST holds.
+  if (collections.length > 0) {
+    const elems = await firstOf(query, [
+      'select class_name, owner_name, attr_name, data_type from db_attr_setdomain_elm',
+      'select class_name, attr_name, data_type from db_attr_setdomain_elm',
+    ]);
+    for (const r of elems ?? []) {
+      // By owner too where the row has one: two owners may have a table of the same name.
+      const owner = str(r.owner_name);
+      for (const { o, c } of collections) {
+        if (owner && o.owner && lower(o.owner) !== lower(owner)) continue;
+        if (lower(o.name) === lower(str(r.class_name)) && lower(c.name) === lower(str(r.attr_name))) {
+          c.elementType = columnType(str(r.data_type), undefined, undefined).type;
+        }
+      }
+    }
+  }
+
+  // --- inheritance ---
+  const supers = await firstOf(query, [
+    'select class_name, owner_name, super_class_name, super_owner_name from db_direct_super_class',
+    'select class_name, super_class_name from db_direct_super_class',
+  ]);
+  for (const r of supers ?? []) {
+    const parent = str(r.super_owner_name) ? `${str(r.super_owner_name)}.${str(r.super_class_name)}` : str(r.super_class_name);
+    eachObject(objectFor(r), (o) => {
+      o.under = [...(o.under ?? []), parent];
+    });
+  }
+
+  // --- keys and indexes ---
+  const keyRows = await firstOf(query, [
+    'select i.class_name, i.owner_name, i.index_name, i.is_unique, i.is_primary_key, i.is_foreign_key, i.comment, k.key_attr_name, k.key_order ' +
+      'from db_index i, db_index_key k where i.index_name = k.index_name and i.class_name = k.class_name and i.owner_name = k.owner_name ' +
+      'order by i.class_name, i.index_name, k.key_order',
+    'select i.class_name, i.index_name, i.is_unique, i.is_primary_key, i.is_foreign_key, i.comment, k.key_attr_name, k.key_order ' +
+      'from db_index i, db_index_key k where i.index_name = k.index_name and i.class_name = k.class_name ' +
+      'order by i.class_name, i.index_name, k.key_order',
+    'select i.class_name, i.index_name, i.is_unique, i.is_primary_key, i.is_foreign_key, k.key_attr_name, k.key_order ' +
+      'from db_index i, db_index_key k where i.index_name = k.index_name and i.class_name = k.class_name ' +
+      'order by i.class_name, i.index_name, k.key_order',
+  ]);
+  if (keyRows) {
+    const idx = new Map<SchemaObject, Map<string, { pk: boolean; fk: boolean; unique: boolean; comment: string | null; columns: string[] }>>();
+    for (const r of keyRows) {
+      eachObject(objectFor(r), (o) => {
+        const forObject = idx.get(o) ?? new Map();
+        idx.set(o, forObject);
+        const name = str(r.index_name);
+        const entry = forObject.get(name) ?? {
+          pk: yes(r.is_primary_key),
+          fk: yes(r.is_foreign_key),
+          unique: yes(r.is_unique),
+          comment: 'comment' in r ? opt(r.comment) : null,
+          columns: [],
+        };
+        forObject.set(name, entry);
+        // An index on an expression has no column name: its columns are not listed.
+        if (str(r.key_attr_name)) entry.columns.push(str(r.key_attr_name));
+      });
+    }
+    for (const o of schema.objects) {
+      if (o.kind === 'view') continue;
+      const forObject = idx.get(o);
+      o.primaryKey = [];
+      o.unique = [];
+      o.indexes = [];
+      if (!forObject) continue;
+      for (const [name, e] of forObject) {
+        if (e.pk) o.primaryKey = e.columns;
+        else if (!e.fk) {
+          if (e.unique) o.unique.push({ name, columns: e.columns });
+          o.indexes.push({ name, columns: e.columns, unique: e.unique, comment: e.comment });
+        }
+      }
+    }
+
+    // Where a foreign key points is only in the table's DDL.
+    for (const o of schema.objects) {
+      const forObject = idx.get(o);
+      const fks = forObject ? [...forObject].filter(([, e]) => e.fk) : [];
+      o.foreignKeys = [];
+      if (fks.length === 0) continue;
+      const target = o.owner ? `${bracket(o.owner)}.${bracket(o.name)}` : bracket(o.name);
+      const ddlRows =
+        (await firstOf(query, [`show create table ${target}`])) ?? (await firstOf(query, [`show create table ${bracket(o.name)}`]));
+      const row = ddlRows?.[0];
+      const ddl = row ? str(Object.values(row)[Object.values(row).length - 1]) : '';
+      const parsed = ddl ? parseForeignKeys(ddl) : [];
+      for (const [name, e] of fks) {
+        const same = (a: string[], b: string[]) => a.length === b.length && a.every((c, i) => lower(c) === lower(b[i] ?? ''));
+        const p = parsed.find((f) => lower(f.name) === lower(name)) ?? parsed.find((f) => same(f.columns, e.columns));
+        o.foreignKeys.push(
+          p ? { ...p, name, columns: e.columns } : { name, columns: e.columns, references: '', refColumns: [] },
+        );
+      }
+    }
+  }
+
+  // --- views ---
+  const views = await firstOf(query, [
+    'select vclass_name, owner_name, vclass_def from db_vclass',
+    'select vclass_name, vclass_def from db_vclass',
+  ]);
+  for (const r of views ?? []) {
+    eachObject(objectFor(r, 'vclass_name'), (o) => {
+      if (o.kind === 'view') o.definition = str(r.vclass_def);
+    });
+  }
+
+  // --- serials, and which columns are AUTO_INCREMENT ---
+  const serials = await firstOf(query, [
+    'select name, owner.name as owner_name, class_name, att_name, comment from db_serial order by name',
+    'select name, class_name, att_name, comment from db_serial order by name',
+    'select name, class_name, att_name from db_serial order by name',
+    'select name from db_serial order by name',
+  ]);
+  if (serials) {
+    schema.serials = [];
+    for (const r of serials) {
+      const cls = str(r.class_name);
+      if (cls && str(r.att_name)) {
+        // An AUTO_INCREMENT column's own serial.
+        for (const o of byName.get(lower(cls)) ?? []) {
+          const c = o.columns?.find((x) => lower(x.name) === lower(str(r.att_name)));
+          if (c) c.autoIncrement = true;
+        }
+        continue;
+      }
+      const s: SchemaSerial = { name: str(r.name) };
+      if (str(r.owner_name)) s.owner = str(r.owner_name);
+      if ('comment' in r) s.comment = opt(r.comment);
+      if (s.name) schema.serials.push(s);
+    }
+  }
+
+  // --- stored procedures and functions ---
+  const procs = await firstOf(query, [
+    'select sp_name, owner, sp_type, return_type, comment from db_stored_procedure order by sp_name',
+    'select sp_name, sp_type, return_type, comment from db_stored_procedure order by sp_name',
+    'select sp_name, sp_type, return_type from db_stored_procedure order by sp_name',
+  ]);
+  if (procs) {
+    const args = await firstOf(query, [
+      'select sp_name, index_of, arg_name, data_type, mode, comment from db_stored_procedure_args order by sp_name, index_of',
+      'select sp_name, index_of, arg_name, data_type, mode from db_stored_procedure_args order by sp_name, index_of',
+    ]);
+    schema.procedures = procs
+      .filter((r) => str(r.sp_name))
+      .map((r) => {
+        const isFunction = str(r.sp_type).toUpperCase() === 'FUNCTION';
+        const p: SchemaProcedure = { name: str(r.sp_name), kind: isFunction ? 'function' : 'procedure' };
+        if (str(r.owner)) p.owner = str(r.owner);
+        if (isFunction && str(r.return_type)) p.returns = str(r.return_type);
+        if ('comment' in r) p.comment = opt(r.comment);
+        if (args) {
+          p.params = args
+            .filter((a) => lower(str(a.sp_name)) === lower(p.name))
+            .map((a) => {
+              const mode = str(a.mode).toUpperCase();
+              const param: SchemaParam = {
+                name: str(a.arg_name),
+                type: str(a.data_type),
+                mode: mode === 'OUT' ? 'OUT' : mode === 'INOUT' ? 'INOUT' : 'IN',
+              };
+              if ('comment' in a) param.comment = opt(a.comment);
+              return param;
+            });
+        }
+        return p;
+      });
+  }
+
+  // --- synonyms ---
+  const synonyms = await firstOf(query, [
+    'select synonym_name, synonym_owner_name, target_name, target_owner_name, comment from db_synonym order by synonym_name',
+    'select synonym_name, synonym_owner_name, target_name, target_owner_name from db_synonym order by synonym_name',
+  ]);
+  if (synonyms) {
+    schema.synonyms = synonyms
+      .filter((r) => str(r.synonym_name))
+      .map((r) => {
+        const s: SchemaSynonym = {
+          name: str(r.synonym_name),
+          target: str(r.target_owner_name) ? `${str(r.target_owner_name)}.${str(r.target_name)}` : str(r.target_name),
+        };
+        if (str(r.synonym_owner_name)) s.owner = str(r.synonym_owner_name);
+        if ('comment' in r) s.comment = opt(r.comment);
+        return s;
+      });
+  }
+
+  return schema;
+}