How does an open lakehouse table format let you query a table as it looked yesterday?

## The problem a snapshot solves Physically, a table on object storage is just a pile of files — usually Parquet or ORC — under some prefix. A bare directory of files has no notion of "the table as of yesterday": if a job overwrote or added files, the only state you can observe is whatever is in the directory right now. There is no version, no history, and no way to ask a question about the past. An open lakehouse table format adds a **table layer** above those files. Instead of "the table is whatever is in this directory," the rule becomes "the table is exactly the set of files that the current table metadata says it is." Once the file list is an explicit, written-down object, it can be versioned — and that is all a snapshot is. ## What a snapshot actually is A snapshot is an immutable record, produced by exactly one commit, of the complete set of data files that constitute the table at that instant, together with the schema and partitioning in effect and usually per-file statistics used for pruning. Three properties matter: - **It is a reference set, not a copy.** A snapshot holds pointers to files, so keeping a hundred snapshots costs metadata, not a hundred copies of the data. - **Data files are immutable.** A file referenced by snapshot 41 is byte-identical forever; nothing rewrites it in place. That is precisely why an old snapshot stays readable — its files were never disturbed. - **Each commit produces exactly one new snapshot.** Snapshots form a lineage, and the table has one *current* snapshot at any moment. ## How each kind of write produces a new snapshot An **append** yields a snapshot whose file set is the old set plus the newly written files. A **delete or update** cannot edit a file, so the format either rewrites the affected files and produces a snapshot referencing the replacements instead of the originals (copy-on-write), or keeps the originals and adds delete markers that readers apply on the fly (merge-on-read). A **compaction** produces a snapshot referencing a few large files instead of many small ones, with identical logical contents. In every case the previous snapshot is untouched and still points at files that still exist. ## Reading an old snapshot Time travel has two addressing modes: ```sql -- as of a wall-clock moment SELECT count(*) FROM sales TIMESTAMP AS OF '2026-08-20 00:00:00'; -- as of a specific committed version SELECT count(*) FROM sales VERSION AS OF 412; ``` Timestamp addressing resolves to the newest snapshot committed at or before the timestamp, so the same timestamp keeps resolving to the same snapshot but *nearby* timestamps drift as new commits land. Version addressing is exact and stable, which is what you want when you record which data an experiment or a report used. Execution is unremarkable: the engine gets a file list from the chosen snapshot and scans it. A time-travel query costs about what the same query costs on the current table. ## What it is good for Debugging a pipeline ("what did this table look like before the bad run?"), reproducing an ML training set or a regulatory report exactly, diffing two versions to see what a job changed, auditing, and — the payoff most interviews want — rolling the table back to a known-good version with one command rather than restoring from a backup. ## What it is not Time travel gives you **table states**, not a row-level change history: you can compare version 411 and 412 yourself, but a per-row change feed is a separate opt-in feature where a format offers one. It is also not a backup — the old snapshot points at files in the same bucket, so anything that destroys those objects destroys the history too. And it is bounded: retention policies expire old snapshots and delete files that no surviving snapshot references, which is what makes the space reclaimable in the first place. Past the retention horizon, an AS OF query simply fails. ## The junior-level takeaway Immutable files plus a versioned list of them equals history for free. You are not paying for a copy of yesterday's table; you are paying to *not delete* yesterday's files yet.