Sail is the right lakehouse substrate for Querygraph because it makes the data layer local, inspectable, Spark-compatible, and Rust-friendly. Querygraph wants to load real Dataverse and CODATA assets, infer strong column types, expose tables to PySpark and Spark Connect, and store audit events next to the data. Sail gives that work a serious execution surface without forcing the demo into a remote warehouse account.
The first principle is that governed AI needs a governed data substrate. Prompting over loose files is not enough. The system needs typed tables, stable locations, query execution, catalog records, and audit tables. Sail gives Querygraph a local lakehouse where data and evidence can live together.
Sail is also part of the alternative to Big AI. If ordinary SQL and Spark operations can answer part of a question, they should. Counting rows, joining tables, filtering by geography, and reading audit events do not require a large language model. They require a reliable execution engine. The model should receive the result of that focused computation, not the entire raw warehouse.
The local schema is qg_lakehouse. It contains typed
tables and catalog records such as lakehouse_datasets,
lakehouse_files, and lakehouse_columns. The
audit schema is qg_audit. It stores OpenLineage events and
DID attestations. That separation mirrors the product boundary: data and
metadata in one governed space, operational evidence in another governed
space, both queryable.
Rust is the right implementation language for this because the system lives at the intersection of parsing, security, metadata, policy, graph traversal, serialization, and reproducibility. These are not soft edges. A loader should not silently coerce a sensitive identifier into nonsense. A policy evaluator should not accidentally treat an absent prohibition as a broad grant. A lineage attestation should not hash a different payload than the one written to audit storage.
Rust helps Querygraph make those boundaries explicit.
Result-driven error handling keeps ingestion honest.
serde keeps JSON-LD, OpenLineage, and TypeDID envelopes
structured. Strong enums make action vocabularies and event types harder
to confuse. Cargo keeps the CLI, library, tests, and book examples close
enough to evolve together. Sail gives the execution layer; Rust gives
the control layer.
Textbook rule: Sail is where focused retrieval becomes executable. It keeps the data local and queryable so the AI layer can remain small, governed, and inspectable.