Returns a primer on the class-table-inheritance model (the `DatabaseObject`
supertable, subclass tables sharing `DB_ID`, the `Class_2_attribute` link
tables, and the stable-id join), the most useful tables, key join recipes,
and the data release loaded. **Read this once before writing `query()` SQL.**
The same primer is also available as the `schema://reactome` MCP resource.

Args:
    filter: If given, only tables whose name contains this substring
        (case-insensitive). e.g. "_2_" for link tables, "Reference" for
        reference-data tables.
    limit: Max tables to return (default 500; the DB has 242).

Returns:
    Dict `{count, tables: [{table, rows, engine}], truncated}`, ordered by
    row count descending. Row counts are exact (all tables are MyISAM).

Args:
    table: Exact table name (see `list_tables`). e.g. "Pathway",
        "Pathway_2_hasEvent", "DatabaseObject".

Returns:
    Dict `{table, columns: [{name, type, nullable, key, default, extra}]}`.

Accepts one `SELECT` / `WITH` / `SHOW` / `DESCRIBE` / `EXPLAIN` statement.
Writes are impossible (the connection is a SELECT-only user) and multiple
statements are rejected. If a `SELECT`/`WITH` has no `LIMIT`, one is injected
automatically. Call `schema_overview` first to learn the join patterns.

Args:
    sql: The statement to run. Use parameter-free SQL; quote literals
        normally. e.g. `SELECT d.DB_ID, d._displayName FROM DatabaseObject d
        JOIN StableIdentifier si ON d.stableIdentifier = si.DB_ID
        WHERE si.identifier = 'R-HSA-69278'`.
    max_rows: Max rows to return (1-5000, default 200). Long text cells are
        also truncated; `truncated` flags either kind.

Returns:
    Dict `{columns, rows, row_count, truncated, sql}` where `rows` is a list
    of lists aligned to `columns`, and `sql` is the statement actually run
    (with any auto-injected LIMIT). On a bad statement or DB error, returns
    `{"error": ...}`.

Resolves a stable id ('R-HSA-69278') or numeric `DB_ID`, then merges the
`DatabaseObject` core fields with the subclass-table attributes that share
the same `DB_ID` (e.g. a Pathway pulls in `Event` + `Pathway` columns).

Args:
    id: An 'R-HSA-...' stable id or a numeric DB_ID.

Returns:
    Dict `{DB_ID, _class, _displayName, stable_id, attributes: {...}}` where
    `attributes` is the union of the subclass rows (leaf class wins on any
    name clash). `{"error": ...}` if the id is unknown.

Args:
    query: Text to look for in the display name.
    classes: Optional `_class` filter, e.g. ["Pathway", "Reaction"].
    limit: Max results (1-200, default 25).
    anchored: If True, match `name LIKE 'query%'` (fast — uses the prefix
        index). If False (default), match `'%query%'` — more thorough but a
        full scan of the 1.86M-row supertable (~1-2s). There are no FULLTEXT
        indexes, so prefer `anchored=True` and/or a `classes` filter for hot
        paths.

Returns:
    Dict `{count, anchored, results: [{DB_ID, _class, _displayName, stable_id}]}`.

Args:
    id: A Pathway stable id ('R-HSA-69278') or numeric DB_ID.

Returns:
    Dict `{pathway_DB_ID, count, events: [{rank, DB_ID, _class,
    _displayName, stable_id}], truncated}`, ordered by `hasEvent_rank`.

Args:
    id: A ReactionlikeEvent (Reaction/BlackBoxEvent/...) stable id or DB_ID.

Returns:
    Dict `{reaction_DB_ID, inputs, outputs, catalysts}` where `inputs`/
    `outputs` are physical-entity dicts and each `catalysts` entry also
    carries `catalyst_activity_DB_ID` and the GO `activity` DB_ID. Empty
    lists if the object isn't a reaction or has none.

Scans a curated set of common containment relations — which pathways contain
this event, which complexes/sets contain this entity, which reactions consume
or produce it. **Best-effort, not exhaustive** (the schema has 132 link
tables; this checks the high-value ones).

Args:
    id: A stable id or numeric DB_ID of the object being referred to.
    attribute: Optionally restrict to one relationship label
        (contained_in_pathway, component_of_complex, member_of_set,
        input_to_reaction, output_of_reaction).
    limit: Max referrers per relation (1-500, default 50).

Returns:
    Dict `{object_DB_ID, referrers: [{relationship, via_table, DB_ID, _class,
    _displayName, stable_id}], scanned, note}`.