WEBSITE ALPHA · AI-assisted, source-reviewed documentation · Full-stack docs reconciled 2026-08-26
64x64base

database schema catalog

The database ecology, family by family.

Cascade ERP is one governed teaching system, not the whole estate. This page also catalogs the MCC datasets, HELP, runtime metadata, identity and AI stores, DataDict, documentation catalogs, localization tables, applications, and fixtures. Counts are measured local snapshots; they describe schema families rather than claiming every replica is a separate logical database.

featured relational system

Cascade ERP dual-carrier schema

34
relational tables
58
foreign-key field edges
9
analytical views

Mermaid -> SVG

Relational schema by working module

This readable system map names every table and shows the principal cross-module paths. Field-level foreign keys remain in the governed dual-schema contract; the public map avoids turning a 58-edge schema into an unreadable wall of lines.

Cascade ERP tables grouped into finance, sales, procurement, inventory, manufacturing, quality, and people modules

carrier contract

SQLite authority and x64base mirror

Structural parity is visible without claiming identical native capabilities. SQLite retains relational enforcement and view SQL. The x64base side provides inspectable DBF projections and snapshots, while sidecars preserve the semantics that DBF cannot enforce.

Read-only SQLite schema inspection flowing through the dual-carrier contract into x64base DBF projections and sidecars

All 34 tables

Finance

  • GL_Accounts
  • GL_Journal
  • AP_Invoices
  • AP_Payments
  • AR_Invoices
  • AR_Payments

Sales

  • Customers
  • Sales_Orders
  • SO_Lines
  • Price_Lists
  • Shipments
  • Shipment_Lines

Procurement

  • Vendors
  • Vendor_Items
  • Purchase_Orders
  • PO_Lines
  • Receiving

Inventory

  • Items
  • Warehouses
  • Stock_Levels
  • Inventory_Movements

Manufacturing

  • BOM_Headers
  • BOM_Details
  • Routings
  • Work_Centers
  • Work_Orders
  • WO_Operations
  • WO_Materials

Quality

  • Quality_Tests
  • Quality_Results

People

  • Departments
  • Employees
  • Payroll_Runs
  • Time_Cards

Nine analytical views

v_AP_Aging
v_AR_Aging
v_Available_Stock
v_BOM_Explosion
v_Open_Sales_Orders
v_Reorder_Alert
v_Three_Way_Match
v_Trial_Balance
v_Work_Order_Status

In SQLite these remain executable views. In the x64base teaching mirror they are labeled materialized snapshots, not silently presented as live relational views.

other database schemas

MCC, HELP, metadata, and the rest of the teaching system

These are first-class schema families, not footnotes to Cascade. The map separates educational datasets, operational catalogs, documentation systems, and disposable fixtures so a learner can see both the data and its purpose.

Database schema catalog showing MCC, HELP, metadata, identity, AI-BBS, AI Portal, DataDict, documentation, locale, application, and fixture families

Education and reference

MCC x64

13 tables

Primary x64 education dataset

carrier: X64 DBF

MCC x32

13 tables

Traditional xBase comparison dataset

carrier: classic DBF

MCC VFP

12 tables

Visual FoxPro interoperability set

carrier: VFP DBF

MCC original

12 tables

Original/reference teaching copy

carrier: reference DBF

Bible x64

13 tables

Packaged scripture teaching database

carrier: SQLite 3

Pinocchio

2 tables

Scale and navigation benchmark fixture

carrier: X64 DBF

Runtime and governance

HELP

10 live + 6 V32

Commands, topics, sections, and localization

carrier: DBF + memo

Runtime metadata

8 tables

Commands, functions, arguments, messages, and fields

carrier: DBF

Identity / RBAC

9 tables

Members, roles, permissions, grants, and assignments

carrier: DBF

AI-BBS

3 tables

Boards, threads, and posts

carrier: DBF

AI Portal tracking

5 tables

Lanes, runs, proofs, tasks, and crosswalks

carrier: DBF

Data dictionary

17 tables

Objects, evidence, relations, gates, and run records

carrier: DBF

Documentation and language

Source comments

8 tables

Files, lines, classes, usages, aliases, and memo lines

carrier: DBF

Manual assembly

8 tables

Runs, sections, review, publication, media, and anchors

carrier: DBF

Messaging

2 tables

Message identity and localized text

carrier: DBF

Locale

2 tables

Locales and fallback rules

carrier: DBF

Applications and fixtures

PyCRUD demo

4 tables

Small CRUD teaching application

carrier: SQLite 3

Memo and dialect fixtures

14 tables

Memo-format and dialect interoperability

carrier: DBF / DBT / FPT

Sandbox and probes

50 tables

Disposable regression and parser surfaces

carrier: generated DBF

Index boundary: LMDB environments, CDX, and CNX are derived index carriers. They are inventoried and governed, but they are not promoted here as independent table schemas. Backups, proof copies, and browser-profile SQLite files are likewise excluded from the logical schema catalog.

the inversion

A table of databases

Every schema above describes a database made of tables. The catalog described here is the other way round: a table whose rows are databases. Not a registry that points at databases living elsewhere -- rows that carry them.

The WORKSPACES catalog is an ordinary x64 table with an ordinary memo field. Each row is one saved workspace: a unique id, the human name you load it by, the flavor and format measured at save time, size, lineage to the row it superseded, who saved it and when, and the roots its tables lived under. The memo field holds the payload. What varies is how much of the database that payload is:

  • A posture -- which tables, which indexes, which tag orders, which relations, and where each cursor sat. Roughly a kilobyte for a thirteen-table system. The tables stay on disk; the row describes how to stand them up.
  • A mini-database -- the posture plus every table's bytes and every attached index's bytes, in one binary-safe container. Ninety-four kilobytes for the same thirteen-table system. Nothing stays on disk; the row is the database, and it can be stood up into memory with no disk source at all.

That is the inversion worth sitting with. A database normally contains tables; here a table contains databases, versioned by the same append-only history the engine gives any other table, attributed to a real member, and verified byte-for-byte when written. Ordinary database machinery -- rows, a memo field, a record lock, an append -- turns out to be enough to hold databases, because nothing in the memo layer ever asked what it was storing.

Why there is a Cascade-sized limit

A mini-database is deliberately mini, and Cascade -- 34 tables, 43 work areas -- is roughly the shape of the ceiling. Three real budgets set it, none of them arbitrary:

  • Work areas. A hydrated workspace occupies engine work-area slots, and the slot table is allocated eagerly rather than on demand. The budget is a build-time vector, measured rather than guessed, and every simultaneous workspace draws from the same pool.
  • Memory. Hydration puts the whole payload in RAM twice at the moment of transfer -- once as the memo string, once as the virtual-disk files. A container that would exceed the RAM budget must be refused, not attempted.
  • Honest carriage. Some things cannot ride at all: LMDB index environments must map a real operating-system file, so they stay on disk by contract rather than by preference.

The governing rule is the house growth doctrine -- strict first, then dynamic. A fixed, stated ceiling that refuses clearly beats an elastic one that degrades mysteriously, and the elastic version is only earned once the fixed one has been measured against real systems. Cascade is that measuring stick: big enough to be a real ERP, small enough to prove the mechanism, and the reason a size-governance seam (estimated hydration cost per row) exists as a column in the catalog before it exists as an enforcement.