superlocalmemory 3.8.0 → 3.8.1

package/src/superlocalmemory/storage/migration_runner.py

@@ -113,6 +113,15 @@ from superlocalmemory.storage.migrations import (
 from superlocalmemory.storage.migrations import (
     M027_transferable_patterns_profile as _M027,
 )
+from superlocalmemory.storage.migrations import (
+    M028_fact_entity_associations as _M028,
+)
+from superlocalmemory.storage.migrations import (
+    M029_behavioral_history_indexes as _M029,
+)
+from superlocalmemory.storage.migrations import (
+    M030_entity_explorer_indexes as _M030,
+)
 
 # Map migration name → module (used for the optional ``verify(conn)`` hook
 # that lets the runner detect "already applied" state when an idempotent
@@ -144,6 +153,9 @@ _MODULES = {
     _M025.NAME: _M025,
     _M026.NAME: _M026,
     _M027.NAME: _M027,
+    _M028.NAME: _M028,
+    _M029.NAME: _M029,
+    _M030.NAME: _M030,
 }
 
 logger = logging.getLogger(__name__)
@@ -218,6 +230,10 @@ MIGRATIONS: list[Migration] = [
 # position proxy when the column is absent, so a failed deferred apply never
 # crashes the trainer — it just keeps the old label path.
 DEFERRED_MIGRATIONS: list[Migration] = [
+    # M028 captures an atomic_facts rowid high-water mark before readiness.
+    # atomic_facts/canonical_entities are bootstrapped by MemoryEngine.
+    Migration(name=_M028.NAME, db_target="memory", ddl=_M028.DDL,
+              dependencies=(_M018.NAME,)),
     Migration(name=_M006.NAME, db_target="memory", ddl=_M006.DDL),
     # M011 extends atomic_facts + creates memory_archive / memory_merge_log.
     # atomic_facts is bootstrapped at engine init, so M011 defers alongside M006.
@@ -256,6 +272,10 @@ DEFERRED_MIGRATIONS: list[Migration] = [
     # consolidation run, not during engine init or apply_all. apply() is a no-op
     # when the table is absent (first install after the schema change).
     Migration(name=_M027.NAME, db_target="learning", ddl=_M027.DDL),
+    # M029 indexes behavioral tables bootstrapped during engine initialization.
+    Migration(name=_M029.NAME, db_target="memory", ddl=_M029.DDL),
+    # M030 bounds Entity Explorer pagination and profile-summary ranking.
+    Migration(name=_M030.NAME, db_target="memory", ddl=_M030.DDL),
 ]
 
 
@@ -401,7 +421,65 @@ def _apply_single(
                 )
                 logger.warning(detail)
                 return ("failed", detail)
-            return ("skipped", "already complete")
+            # A matching migration-log row is not proof that the promised
+            # schema still exists. Existing installs can retain a migration log
+            # while a partial restore drops an additive table or index.
+            #
+            # Never replay a historical migration merely because verify()
+            # fails. Some migrations rebuild tables and transform data; replay
+            # would be destructive (M002 is the canonical example). Only a
+            # module-supplied repair(conn) hook is allowed to reconcile a
+            # completed migration's end-state.
+            mod = _MODULES.get(migration.name)
+            verify_fn = (
+                getattr(mod, "verify", None) if mod is not None else None
+            )
+            if verify_fn is None:
+                return ("skipped", "already complete")
+            try:
+                schema_complete = bool(verify_fn(conn))
+            except sqlite3.Error as exc:
+                return (
+                    "failed",
+                    f"schema verification failed for {migration.name}: {exc}",
+                )
+            if schema_complete:
+                return ("skipped", "already complete (schema verified)")
+            if dry_run:
+                return (
+                    "skipped",
+                    "dry-run: would repair missing migration end-state",
+                )
+            repair_fn = (
+                getattr(mod, "repair", None) if mod is not None else None
+            )
+            if not callable(repair_fn):
+                detail = (
+                    f"schema incomplete for completed migration "
+                    f"{migration.name}; automatic replay is disabled"
+                )
+                logger.warning(detail)
+                return ("failed", detail)
+            try:
+                repair_fn(conn)
+            except sqlite3.Error as exc:
+                return (
+                    "failed",
+                    f"safe repair failed for {migration.name}: {exc}",
+                )
+            try:
+                if not bool(verify_fn(conn)):
+                    return (
+                        "failed",
+                        f"safe repair did not restore {migration.name}",
+                    )
+            except sqlite3.Error as exc:
+                return (
+                    "failed",
+                    f"post-repair verification failed for "
+                    f"{migration.name}: {exc}",
+                )
+            return ("applied", "missing end-state repaired safely")
         # status is 'failed' or 'in_progress' → retry from scratch.
         if dry_run:
             return ("skipped", f"dry-run: would retry (status={status})")

package/src/superlocalmemory/storage/migrations/M010_evolution_config.py

@@ -50,6 +50,11 @@ def verify(conn: sqlite3.Connection) -> bool:
     return _REQUIRED_TABLES.issubset(names)
 
 
+def repair(conn: sqlite3.Connection) -> None:
+    """Restore additive Skill Evolution tables without replaying other migrations."""
+    conn.executescript(DDL)
+
+
 DDL = """
 CREATE TABLE IF NOT EXISTS evolution_config (
     profile_id        TEXT PRIMARY KEY,

package/src/superlocalmemory/storage/migrations/M028_fact_entity_associations.py

@@ -0,0 +1,270 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later
+
+"""M028 — normalized fact/entity associations for O(1) ingest effects.
+
+The table is both an association index and an idempotency ledger.  Its
+composite primary key means a fact can contribute to an entity's ``fact_count``
+once, regardless of ingestion retries or how many operations converge on the
+same consolidated fact.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import UTC, datetime
+from pathlib import Path
+
+NAME = "M028_fact_entity_associations"
+DB_TARGET = "memory"
+
+DDL = """
+CREATE TABLE IF NOT EXISTS fact_entity_associations (
+    profile_id TEXT NOT NULL,
+    fact_id TEXT NOT NULL,
+    entity_id TEXT NOT NULL,
+    first_operation_id TEXT NOT NULL DEFAULT '',
+    count_applied INTEGER NOT NULL DEFAULT 0
+        CHECK (count_applied IN (0, 1)),
+    created_at TEXT NOT NULL DEFAULT (
+        strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+    ),
+    PRIMARY KEY (profile_id, fact_id, entity_id),
+    FOREIGN KEY (fact_id) REFERENCES atomic_facts(fact_id) ON DELETE CASCADE,
+    FOREIGN KEY (entity_id)
+        REFERENCES canonical_entities(entity_id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_fact_entity_associations_entity
+    ON fact_entity_associations(profile_id, entity_id, fact_id);
+CREATE TABLE IF NOT EXISTS fact_entity_association_repair_state (
+    repair_key TEXT PRIMARY KEY,
+    state TEXT NOT NULL DEFAULT 'pending'
+        CHECK (state IN ('pending', 'running', 'retrying', 'complete')),
+    target_fact_rowid INTEGER NOT NULL DEFAULT -1,
+    last_fact_rowid INTEGER NOT NULL DEFAULT 0,
+    scanned INTEGER NOT NULL DEFAULT 0,
+    inserted INTEGER NOT NULL DEFAULT 0,
+    last_error TEXT NOT NULL DEFAULT '',
+    updated_at TEXT NOT NULL
+);
+"""
+
+
+def _table_exists(conn: sqlite3.Connection, table: str) -> bool:
+    return conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name=?",
+        (table,),
+    ).fetchone() is not None
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    """Install schema and capture a constant-time historical rowid boundary."""
+    conn.executescript(DDL)
+    association_columns = {
+        row[1]
+        for row in conn.execute(
+            "PRAGMA table_info(fact_entity_associations)"
+        ).fetchall()
+    }
+    if "count_applied" not in association_columns:
+        conn.execute(
+            "ALTER TABLE fact_entity_associations "
+            "ADD COLUMN count_applied INTEGER NOT NULL DEFAULT 0 "
+            "CHECK (count_applied IN (0, 1))"
+        )
+    repair_columns = {
+        row[1]
+        for row in conn.execute(
+            "PRAGMA table_info(fact_entity_association_repair_state)"
+        ).fetchall()
+    }
+    if "target_fact_rowid" not in repair_columns:
+        conn.execute(
+            "ALTER TABLE fact_entity_association_repair_state "
+            "ADD COLUMN target_fact_rowid INTEGER NOT NULL DEFAULT -1"
+        )
+    target = int(conn.execute(
+        "SELECT COALESCE(MAX(rowid), 0) FROM atomic_facts"
+    ).fetchone()[0])
+    conn.executescript(
+        "INSERT OR IGNORE INTO fact_entity_association_repair_state "
+        "(repair_key,state,target_fact_rowid,updated_at) "
+        f"VALUES ('historical-backfill','pending',{target},'');"
+        "UPDATE fact_entity_association_repair_state "
+        f"SET target_fact_rowid={target} "
+        "WHERE repair_key='historical-backfill' AND target_fact_rowid < 0;"
+    )
+
+
+def _now() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def _connect(db_path: Path) -> sqlite3.Connection:
+    conn = sqlite3.connect(str(db_path), timeout=5)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA busy_timeout=5000")
+    conn.execute("PRAGMA foreign_keys=ON")
+    return conn
+
+
+def get_repair_status(db_path: Path) -> dict[str, int | str]:
+    """Read durable backfill progress without inferring it from schema."""
+    conn = _connect(Path(db_path))
+    try:
+        row = conn.execute(
+            "SELECT state,target_fact_rowid,last_fact_rowid,scanned,inserted,"
+            "last_error,updated_at "
+            "FROM fact_entity_association_repair_state "
+            "WHERE repair_key='historical-backfill'"
+        ).fetchone()
+        if row is None:
+            return {
+                "state": "pending", "target_fact_rowid": 0,
+                "last_fact_rowid": 0,
+                "scanned": 0, "inserted": 0,
+                "last_error": "", "updated_at": "",
+            }
+        return dict(row)
+    finally:
+        conn.close()
+
+
+def _entity_ids(raw: object) -> tuple[str, ...]:
+    try:
+        values = json.loads(str(raw or "[]"))
+    except (TypeError, ValueError):
+        return ()
+    if not isinstance(values, list):
+        return ()
+    return tuple(dict.fromkeys(str(value) for value in values if value))
+
+
+def _repair_batch(conn: sqlite3.Connection, batch_size: int) -> dict[str, int | bool]:
+    conn.execute("BEGIN IMMEDIATE")
+    try:
+        status = conn.execute(
+            "SELECT last_fact_rowid,target_fact_rowid "
+            "FROM fact_entity_association_repair_state "
+            "WHERE repair_key='historical-backfill'"
+        ).fetchone()
+        cursor = int(status["last_fact_rowid"] or 0)
+        target = int(status["target_fact_rowid"])
+        rows = conn.execute(
+            "SELECT rowid,fact_id,profile_id,canonical_entities_json "
+            "FROM atomic_facts WHERE rowid>? AND rowid<=? "
+            "ORDER BY rowid LIMIT ?",
+            (cursor, target, batch_size),
+        ).fetchall()
+        if not rows:
+            conn.execute(
+                "UPDATE fact_entity_association_repair_state "
+                "SET state='complete',last_error='',updated_at=? "
+                "WHERE repair_key='historical-backfill'",
+                (_now(),),
+            )
+            conn.commit()
+            return {"scanned": 0, "inserted": 0, "complete": True}
+        inserted = 0
+        for row in rows:
+            for entity_id in _entity_ids(row["canonical_entities_json"]):
+                result = conn.execute(
+                    "INSERT OR IGNORE INTO fact_entity_associations "
+                    "(profile_id,fact_id,entity_id,first_operation_id,"
+                    "count_applied) "
+                    "SELECT ?,?,?,?,? FROM canonical_entities "
+                    "WHERE profile_id=? AND entity_id=?",
+                    (
+                        row["profile_id"], row["fact_id"], entity_id,
+                        "migration-backfill", 0,
+                        row["profile_id"], entity_id,
+                    ),
+                )
+                inserted += max(0, result.rowcount)
+        conn.execute(
+            "UPDATE fact_entity_association_repair_state SET "
+            "state='running',last_fact_rowid=?,scanned=scanned+?,"
+            "inserted=inserted+?,last_error='',updated_at=? "
+            "WHERE repair_key='historical-backfill'",
+            (int(rows[-1]["rowid"]), len(rows), inserted, _now()),
+        )
+        conn.commit()
+        return {"scanned": len(rows), "inserted": inserted, "complete": False}
+    except Exception:
+        conn.rollback()
+        raise
+
+
+def repair_fact_entity_associations(
+    db_path: Path,
+    *,
+    batch_size: int = 250,
+    max_batches: int = 1,
+) -> dict[str, int | bool]:
+    """Run bounded, restartable short-transaction backfill batches."""
+    if batch_size < 1 or max_batches < 1:
+        raise ValueError("batch_size and max_batches must be positive")
+    totals = {"scanned": 0, "inserted": 0, "complete": False}
+    conn = _connect(Path(db_path))
+    try:
+        for _ in range(max_batches):
+            result = _repair_batch(conn, batch_size)
+            totals["scanned"] += int(result["scanned"])
+            totals["inserted"] += int(result["inserted"])
+            totals["complete"] = bool(result["complete"])
+            if totals["complete"]:
+                break
+        return totals
+    except sqlite3.Error as exc:
+        try:
+            conn.execute(
+                "UPDATE fact_entity_association_repair_state SET "
+                "state='retrying',last_error=?,updated_at=? "
+                "WHERE repair_key='historical-backfill'",
+                (type(exc).__name__, _now()),
+            )
+            conn.commit()
+        except sqlite3.Error:
+            pass
+        raise
+    finally:
+        conn.close()
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    """Return true when the normalized association contract is indexed."""
+    if not (
+        _table_exists(conn, "fact_entity_associations")
+        and _table_exists(conn, "fact_entity_association_repair_state")
+    ):
+        return False
+    association_columns = {
+        row[1]
+        for row in conn.execute(
+            "PRAGMA table_info(fact_entity_associations)"
+        ).fetchall()
+    }
+    repair_columns = {
+        row[1]
+        for row in conn.execute(
+            "PRAGMA table_info(fact_entity_association_repair_state)"
+        ).fetchall()
+    }
+    if (
+        "count_applied" not in association_columns
+        or "target_fact_rowid" not in repair_columns
+    ):
+        return False
+    indexes = {
+        row[1]
+        for row in conn.execute(
+            "PRAGMA index_list(fact_entity_associations)"
+        ).fetchall()
+    }
+    return "idx_fact_entity_associations_entity" in indexes
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    """Restore additive M028 schema without recapturing its high-water mark."""
+    apply(conn)

package/src/superlocalmemory/storage/migrations/M029_behavioral_history_indexes.py

@@ -0,0 +1,137 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later
+
+"""M029 — profile-scoped indexes for large behavioral histories.
+
+Dashboard reads always filter behavioral and outcome history by profile before
+sorting or aggregating. These composite indexes keep those operations bounded
+to one tenant as the shared database grows.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M029_behavioral_history_indexes"
+DB_TARGET = "memory"
+
+DDL = """
+CREATE INDEX IF NOT EXISTS idx_outcomes_profile_outcome_time
+    ON action_outcomes(profile_id, outcome, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_outcomes_profile_settled_time
+    ON action_outcomes(profile_id, settled, settled_at DESC);
+CREATE INDEX IF NOT EXISTS idx_outcomes_profile_settled_cursor
+    ON action_outcomes(
+        profile_id, settled, COALESCE(settled_at, ''), outcome_id
+    );
+CREATE INDEX IF NOT EXISTS idx_assertions_profile_confidence
+    ON behavioral_assertions(profile_id, confidence DESC);
+CREATE INDEX IF NOT EXISTS idx_tool_events_profile_created
+    ON tool_events(profile_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_soft_prompts_profile_active_category
+    ON soft_prompt_templates(profile_id, active, category, prompt_id);
+"""
+
+_INDEXES: tuple[tuple[str, str, tuple[str, ...]], ...] = (
+    (
+        "idx_outcomes_profile_outcome_time",
+        "action_outcomes",
+        ("profile_id", "outcome", "timestamp"),
+    ),
+    (
+        "idx_outcomes_profile_settled_time",
+        "action_outcomes",
+        ("profile_id", "settled", "settled_at"),
+    ),
+    (
+        "idx_outcomes_profile_settled_cursor",
+        "action_outcomes",
+        ("profile_id", "settled", "settled_at", "outcome_id"),
+    ),
+    (
+        "idx_assertions_profile_confidence",
+        "behavioral_assertions",
+        ("profile_id", "confidence"),
+    ),
+    (
+        "idx_tool_events_profile_created",
+        "tool_events",
+        ("profile_id", "created_at"),
+    ),
+    (
+        "idx_soft_prompts_profile_active_category",
+        "soft_prompt_templates",
+        ("profile_id", "active", "category", "prompt_id"),
+    ),
+)
+
+
+def _columns(conn: sqlite3.Connection, table: str) -> set[str]:
+    return {
+        str(row[1])
+        for row in conn.execute(f"PRAGMA table_info({table})").fetchall()
+    }
+
+
+def _index_sql(name: str) -> str:
+    statements = {
+        "idx_outcomes_profile_outcome_time": (
+            "CREATE INDEX IF NOT EXISTS idx_outcomes_profile_outcome_time "
+            "ON action_outcomes(profile_id, outcome, timestamp DESC)"
+        ),
+        "idx_outcomes_profile_settled_time": (
+            "CREATE INDEX IF NOT EXISTS idx_outcomes_profile_settled_time "
+            "ON action_outcomes(profile_id, settled, settled_at DESC)"
+        ),
+        "idx_outcomes_profile_settled_cursor": (
+            "CREATE INDEX IF NOT EXISTS idx_outcomes_profile_settled_cursor "
+            "ON action_outcomes("
+            "profile_id, settled, COALESCE(settled_at, ''), outcome_id)"
+        ),
+        "idx_assertions_profile_confidence": (
+            "CREATE INDEX IF NOT EXISTS idx_assertions_profile_confidence "
+            "ON behavioral_assertions(profile_id, confidence DESC)"
+        ),
+        "idx_tool_events_profile_created": (
+            "CREATE INDEX IF NOT EXISTS idx_tool_events_profile_created "
+            "ON tool_events(profile_id, created_at DESC)"
+        ),
+        "idx_soft_prompts_profile_active_category": (
+            "CREATE INDEX IF NOT EXISTS "
+            "idx_soft_prompts_profile_active_category "
+            "ON soft_prompt_templates(profile_id, active, category, prompt_id)"
+        ),
+    }
+    return statements[name]
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    """Add each index supported by the installed runtime schema.
+
+    Optional v3.2/v3.4.7 tables also declare these indexes in their owning
+    schema modules, so a partial bootstrap cannot permanently miss an index
+    when those tables are created later.
+    """
+    for name, table, required_columns in _INDEXES:
+        if set(required_columns) <= _columns(conn, table):
+            conn.execute(_index_sql(name))
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    """Require each index whose backing table and columns are present."""
+    names = {
+        str(row[0])
+        for row in conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='index'"
+        ).fetchall()
+    }
+    return all(
+        name in names
+        for name, table, required_columns in _INDEXES
+        if set(required_columns) <= _columns(conn, table)
+    )
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    """Create only indexes supported by the current optional schema."""
+    apply(conn)

package/src/superlocalmemory/storage/migrations/M030_entity_explorer_indexes.py

@@ -0,0 +1,93 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later
+
+"""M030 — page-first Entity Explorer indexes for large installations."""
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M030_entity_explorer_indexes"
+DB_TARGET = "memory"
+
+DDL = """
+CREATE INDEX IF NOT EXISTS idx_entities_profile_fact_count_id
+    ON canonical_entities(profile_id, fact_count DESC, entity_id ASC);
+CREATE INDEX IF NOT EXISTS idx_entities_profile_type_fact_count_id
+    ON canonical_entities(
+        profile_id, entity_type COLLATE NOCASE, fact_count DESC, entity_id ASC
+    );
+CREATE INDEX IF NOT EXISTS idx_entity_profiles_profile_entity_rank
+    ON entity_profiles(
+        profile_id, entity_id, last_compiled_at DESC,
+        project_name COLLATE NOCASE
+    );
+"""
+
+_INDEXES: tuple[tuple[str, str, tuple[str, ...], str], ...] = (
+    (
+        "idx_entities_profile_fact_count_id",
+        "canonical_entities",
+        ("profile_id", "fact_count", "entity_id"),
+        "CREATE INDEX IF NOT EXISTS idx_entities_profile_fact_count_id "
+        "ON canonical_entities(profile_id, fact_count DESC, entity_id ASC)",
+    ),
+    (
+        "idx_entities_profile_type_fact_count_id",
+        "canonical_entities",
+        ("profile_id", "entity_type", "fact_count", "entity_id"),
+        "CREATE INDEX IF NOT EXISTS idx_entities_profile_type_fact_count_id "
+        "ON canonical_entities("
+        "profile_id, entity_type COLLATE NOCASE, fact_count DESC, entity_id ASC"
+        ")",
+    ),
+    (
+        "idx_entity_profiles_profile_entity_rank",
+        "entity_profiles",
+        (
+            "profile_id",
+            "entity_id",
+            "last_compiled_at",
+            "project_name",
+        ),
+        "CREATE INDEX IF NOT EXISTS idx_entity_profiles_profile_entity_rank "
+        "ON entity_profiles("
+        "profile_id, entity_id, last_compiled_at DESC, "
+        "project_name COLLATE NOCASE"
+        ")",
+    ),
+)
+
+
+def _columns(conn: sqlite3.Connection, table: str) -> set[str]:
+    return {
+        str(row[1])
+        for row in conn.execute(f"PRAGMA table_info({table})").fetchall()
+    }
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    """Create every index supported by the installed optional schema."""
+    for _, table, required_columns, sql in _INDEXES:
+        if set(required_columns) <= _columns(conn, table):
+            conn.execute(sql)
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    """Require indexes only when their complete backing schema exists."""
+    names = {
+        str(row[0])
+        for row in conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='index'"
+        ).fetchall()
+    }
+    return all(
+        name in names
+        for name, table, required_columns, _ in _INDEXES
+        if set(required_columns) <= _columns(conn, table)
+    )
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    """Safely restore a dropped index without replaying data migrations."""
+    apply(conn)

package/src/superlocalmemory/storage/migrations/__init__.py

@@ -26,6 +26,8 @@ from . import (
     M015_add_pinned_column,
     M019_derivation_lineage,
     M020_model_state_integrity,
+    M029_behavioral_history_indexes,
+    M030_entity_explorer_indexes,
 )
 
 # ---------------------------------------------------------------------------
@@ -77,6 +79,8 @@ __all__ = (
     "M015_add_pinned_column",
     "M019_derivation_lineage",
     "M020_model_state_integrity",
+    "M029_behavioral_history_indexes",
+    "M030_entity_explorer_indexes",
     # Legacy re-exports (backward compat):
     "CURRENT_SCHEMA_VERSION",
     "get_schema_version",