Skip to content

Systems and records

Dataset deletion version lineage: erase the record, keep the event

By SourceX Editorial · Reviewed by Noah Loul ·

8 sections

Short answer

Dataset deletion version lineage should record a deletion as an event instead of erasing the past. Publish a new version without the record, purge its content from every snapshot and copy you control, and keep a ledger entry with an opaque ID, the versions affected, the reason, the approver and each recipient notice. Keep per-record results so old scores can be recomputed on the surviving set; without them, an old result can only be bounded.

Provenance trail

Dataset deletion version

This page covers dataset deletion version lineage: erase the record, keep the event.Illustrative

Key takeaways

  • A delete in Delta Lake or Apache Iceberg adds a version; older snapshots keep the row until purge and cleanup run, and tagged snapshots keep it longer.
  • After deletions, every old release is reproducible, rebuildable on survivors, describable only or unverifiable, depending on what was recorded when it shipped.
  • Removing k of n records can move a recorded score to anywhere between (c - k) / (n - k) and c / (n - k), so rankings within k records are unsettled.
  • GitHub's public DMCA ledger shows removals get disputed and reach derived copies: 556 counter-notices, retractions and reversals, and 2025 networks totaling 41,476 repositories.
  • Article 19 of the GDPR and California Civil Code 1798.105(c)(1) can require telling recipients about an erasure, so the recipient list belongs in the ledger.

What does a deleted record have to leave behind in your lineage?

It has to leave an event, not content. After a deletion, your lineage should still answer three questions: which released versions contained the record, which recipients hold those versions, and which recorded results depended on it. Everything else about the record, its fields, text and attachments, should be gone from every place you control once the purge finishes.

Rewriting history is the shortcut that breaks this. A team edits release 1.0 in place, drops the rows and republishes under the same name. Recipients who downloaded the original now hold a file that no longer matches the published checksum, last quarter's evaluation can no longer be reproduced or explained, and nothing in the release itself shows that anything changed.

Three terms keep the work straight. A logical deletion publishes a new version without the record. A physical purge removes its bytes from the storage, snapshots and backups you control. A ledger entry records that the deletion happened, why, on whose approval and who was told, while holding no copy of the deleted content. Dataset deletion version lineage needs all three, and a DELETE statement on its own delivers only the first.

Why does your table format still hold the row you deleted?

Because modern table formats are designed to keep history, and a delete only adds a version. Until you run the format's cleanup, older snapshots still contain the row, and anyone allowed to time travel can read it.

Delta Lake's documentation spells out the steps. Rows removed through deletion vectors are soft-deletes that logically modify existing Parquet files; the change becomes physical only when files are rewritten, and REORG TABLE ... APPLY (PURGE) rewrites every file holding such rows, after which VACUUM must still delete the old files. VACUUM is not triggered automatically, its default retention threshold is 7 days, and once it runs you can no longer time travel to versions older than the retention period. The table property governing how long logically deleted files are kept defaults to one week, and table history defaults to 30 days.

Apache Iceberg works the same way in its own vocabulary. Its Spark procedures page says every write, update, delete, upsert or compaction produces a new snapshot while the old data and metadata stay around for snapshot isolation and time travel. Snapshots accumulate until they are expired, and the default maximum snapshot age used when expiring is 5 days. Iceberg also lets teams tag snapshots to keep them for audit, and its documentation names handling GDPR requirements as one use of branching and tagging.

That leaves a conflict to settle before the first release ships. A tag that keeps release 1.0 reproducible also keeps every row later deleted from it. You cannot hold a byte-exact old release and a completed purge at once, so decide per deletion reason which one wins and write the rule down. The table format supplies versions and cleanup commands; it does not supply the ledger, the recipient list or the decision.

Which of four states will an old release be left in?

Every past release lands in one of four states after deletions, and its state decides what anyone may still claim about it. The deciding factor is not whether the old bytes survive. It is what you recorded about the release on the day it shipped.

Illustrative: a support-ticket release 1.0 ships with 40,000 records. Three are erased on customer request and release 1.1 replaces it; a year later a retention rule ages out 1,200 older tickets and release 1.2 follows. If the team kept a record-level manifest with opaque IDs and stored each evaluation's per-record outcomes, release 1.0 is rebuildable on survivors: anyone can reconstruct 1.0 minus the deleted IDs and rescore old systems on exactly that set. If it kept only file checksums and counts, 1.0 is describable only.

What each state preserves, and what it permits, is set out in the table below:

Which of four states will an old release be left in?
State of the old releaseWhat still existsWhat a recipient can still doWhat you may claim about old resultsTypical cause
ReproducibleOriginal bytes, retained lawfully under the release termsRerun any test byte for byteOld scores stand exactly as recordedRemoval for quality reasons, with the old release kept under its terms
Rebuildable on survivorsRecord-level manifest with opaque IDs and hashes, per-record results and the ledger; deleted content purgedRebuild the old release minus deleted IDs and rescore on that setThe original score plus an exact bridge score on surviving recordsErasure or rights withdrawal handled with record-level lineage
Describable onlyCounts, task mix, file checksums and the ledger, without per-record resultsRead what changed, but not rebuild the old setA bounded range for each old score, not a new point estimateA clean purge, but evaluations logged only aggregate scores
UnverifiableA release name and perhaps a file, with no manifest or ledgerNothing a reviewer can rely onNo comparison across the deletionRows dropped in place and republished under the old name
A version chain from release 1.0 to 1.1 to 1.2, where three erased records and 1,200 aged-out records leave the data but stay as entries in a deletion ledger, and release 1.0 is marked rebuildable on survivors.
Illustrative: delete the record, keep the event. Counts are the article's worked example, not measured data.

How far can a deletion move a score you already published?

Further than most teams expect on a small evaluation set, and you can compute the worst case before rerunning anything. If a set had n records, a system answered c of them correctly, and k records are deleted, the system's score on the survivors must fall between (c - k) / (n - k) and c / (n - k).

Illustrative: on a 400-record set, a system scored 70.0%, or 280 correct. Deleting 12 records puts its score on the survivors anywhere from 69.1% (268 of 388, if all 12 were records it got right) to 72.2% (280 of 388, if all 12 were records it missed). A second system at 68.5%, or 274 correct, trails by six records. If seven or more of the 12 deleted records were ones the first system solved and the second missed, their order flips.

Per-record results remove the guesswork. With each system's outcome stored against the record's opaque ID, a bridge score is a lookup rather than a rerun, and it needs none of the deleted content. Leave the originally reported score untouched, publish the bridge score beside it with the release that caused it, and state the bound wherever only aggregates survive.

One working rule follows from the arithmetic: when two systems you compare are separated by k or fewer records, treat their ranking as unsettled until bridge scores exist.

What does a public removal ledger look like after fifteen years?

GitHub's public DMCA repository is a long-running open example of the pattern: content is disabled, yet the request that removed it stays on the record. We counted its files to see what a long-running removal ledger accumulates.

GitHub says it publishes takedown notices and counter-notices as received, redacting only private information and URLs it found not actionable, and that a posted notice does not mean the content was unlawful. At commit f277d32 (October 26, 2026) the repository held 21,829 files we classed as takedown notices from January 2011 on, including 2,463 in 2025 and at least 1,759 in every full year since 2018.

Three findings carry over to datasets. Removals get disputed: next to the notices sit 444 counter-notices, 90 retractions and 22 reversals, so a ledger needs a reinstated state as well as a deleted one. One request reaches derived copies: in 2025, 72 notices (2.9%) carried GitHub's note that it processed the notice against an entire network of repositories, and those networks totaled 41,476 repositories including parents, with a median of 158 and a largest of 9,225. Granularity sets the blast radius: GitHub's README says it cannot disable access to specific files within a repository, so it gives owners a chance to change the content or disables whole repositories, the same choice a supplier faces when its release format cannot drop a single record.

Method: we classified file names by type (reversal or revert first, then retraction, then counter-notice, otherwise notice), counted them by year from the repository tree, and read network sizes from GitHub's own annotation in the 2025 files, counting once a network that one notice annotates twice. The data folder is excluded, the counts depend on GitHub's file naming, and a notice file records a request received, not proof that anything was removed. The counting script and its definitions are kept with this article's review files.

Do deletions quietly change the task your data represents?

Often they do, because deletions are rarely random, and a release that loses records by rule can drift away from the task it was licensed to represent. That is the strongest objection to treating a deletion as bookkeeping: the survivors may describe a different job.

Retention schedules remove the oldest records first, so each release's time window slides forward. Erasure requests cluster among the customers who are most privacy-minded or most unhappy. Legal holds keep exactly the disputed cases that a schedule would otherwise drop. Each pattern shifts the mix of task types, periods and outcomes, and a model scored on the survivors is being scored on a narrower question.

Test it release by release against the intended task distribution written into the data requirement. Compare task-type shares, period coverage and outcome balance between the old release and its survivors, and agree in advance on the shift that turns a deletion release into a new dataset with a new baseline.

Downstream copies will not follow your deletions on their own. Peng, Mathur and Narayanan found that after the DukeMTMC and MS-Celeb-1M datasets were retracted, their data stayed widely available and kept appearing in research papers, and that derivatives which added annotations or further processing raised issues of their own. A lineage that stops at your own storage has not tracked the deletion.

Who approves a deletion release, and who has to be told?

Treat a deletion release like any other release: a named approver signs it, and every recipient of an affected version receives a notice saying what to do. Both the approval chain and the notice list should come from the ledger, not from someone's memory of who downloaded what.

Each ledger entry carries an opaque record ID that cannot be traced back to the person or customer, the first and last versions that contained the record, a reason code (erasure request, rights withdrawal, error or retention), the approver and date, purge status for each storage location and snapshot, the releases issued because of it, and each recipient's notice and acknowledgment dates.

Privacy law can make the notice mandatory. Under Article 19 of the GDPR, a controller must communicate an erasure carried out under Article 17(1) to each recipient to whom the personal data were disclosed, unless that proves impossible or involves disproportionate effort, and must tell the data subject about those recipients on request; in Proximus (C-129/21) the Court of Justice read this as a duty, in principle, to pass any erasure on to each recipient. California Civil Code section 1798.105(c)(1) requires a business that receives a verifiable deletion request to notify its service providers and contractors, and all third parties to whom it sold or shared the personal information, unless this proves impossible or involves disproportionate effort. Both duties reach only personal data within each law's scope, and counsel should confirm how they apply to a given release.

Before a deletion release goes out, work through this change-impact checklist:

  • Reason code recorded and approved by the data owner, with privacy or legal sign-off for erasure and rights cases.
  • Every version that held the record found from the record-level manifest, including tagged and archived snapshots.
  • Purge scheduled for each location (live table, snapshots past retention, exports, backups and processor copies), each with an expected completion date.
  • A new version number issued; no published release edited in place.
  • Task mix, period coverage and outcome balance compared with the intended distribution, and a new baseline declared if the agreed threshold is crossed.
  • Bridge scores computed from per-record results, or a bound stated where only aggregate scores exist.
  • Notices sent to every recipient of an affected version with the action required, and acknowledgments tracked to closure.
  • A reinstatement path recorded in case the request is withdrawn or reversed.

Naming the deletion lineage you need in a data request

Ask for deletion lineage before records are delivered, because no supplier can rebuild a ledger it never kept. Datasets requested through SourceX are sourced from U.S. businesses to fit each request rather than drawn from an inventory, so the request itself is where you specify record-level manifests with opaque IDs, a deletion ledger, how per-record evaluation outcomes will be retained, the evidence you expect when a purge completes, and the acceptance test a delivered release must pass.

On the supply side, the business that holds the records approves the scope and terms and signs before any data reaches SourceX, and de-identification is carried out by SourceX directly or through its processing partner. A deletion that arrives after delivery is then settled by the signed agreement and the ledger together, so agree any notice timing you depend on in the deal itself rather than assuming a default.

Frequently asked questions

Is running DELETE on a Delta Lake or Iceberg table enough to erase a record?

No. A delete creates a new table version, and older snapshots keep the row until cleanup runs. In Delta Lake that means REORG TABLE ... APPLY (PURGE) for rows held in deletion vectors, then VACUUM once the retention period has passed (7 days by default). In Iceberg it means expiring every snapshot that still references the data, including any you tagged for audit.

Should the version number change when records are deleted from a dataset?

Yes. A deletion changes what the release contains, so it needs a new version and a ledger entry; editing a published release in place leaves recipients with files that no longer match what was published. Whether the change counts as minor or major depends on whether the task mix shifted past the threshold agreed in the data requirement.

Can scores from before a deletion still be compared with scores after it?

Yes, if per-record results were kept: rescore every system on the surviving records and publish that bridge score next to the original. If only aggregate scores exist, compute the bound (c - k) / (n - k) to c / (n - k) and treat any two systems separated by k or fewer records as unranked until they are rescored.

Do recipients of an earlier dataset release have to be told about a deletion?

Often, yes. For personal data, GDPR Article 19 requires a controller to pass an erasure on to each recipient unless that is impossible or involves disproportionate effort, and California's Civil Code 1798.105(c)(1) requires notifying service providers, contractors and third parties the information was sold or shared with. Contracts can add duties beyond these, so counsel should confirm the obligations for each release.

What should a deletion ledger keep if it cannot keep the deleted content?

The event: an opaque record ID, the first and last versions that contained the record, a reason code, the approver and date, purge status for each storage location, the releases issued because of it, and each recipient's notice and acknowledgment dates. It also needs a reinstated state, because removal requests are sometimes withdrawn or reversed.

Sources

  • Delta Lake's VACUUM is not triggered automatically, its default retention threshold is 7 days, and time travel to versions older than the retention period is lost after it runs; table history is kept for 30 days by default. Source
  • Delta Lake's delta.deletedFileRetentionDuration keeps logically deleted data files for interval 1 week by default, and delta.logRetentionDuration keeps table history for interval 30 days by default. Source
  • Delta Lake deletion vectors record soft-deletes; REORG TABLE ... APPLY (PURGE) rewrites files holding soft-deleted rows, and VACUUM is then needed to physically delete the old files. Source
  • In Apache Iceberg every write, update, delete, upsert or compaction produces a new snapshot while old data and metadata are kept for snapshot isolation and time travel; expire_snapshots removes old snapshots. Source
  • Iceberg's history.expire.max-snapshot-age-ms defaults to 432000000 (5 days) as the maximum snapshot age kept when expiring snapshots. Source
  • Iceberg branches and tags can retain historical snapshots for auditing, and the documentation lists handling GDPR requirements as a use of branching and tagging. Source
  • GitHub publishes DMCA takedown notices and counter-notices as received, redacting private information; this article's counts of notices, follow-ups and fork-network notes come from the repository at commit f277d32. Source
  • GDPR Article 19 requires a controller to communicate erasure under Article 17(1) to each recipient unless impossible or disproportionate, and to inform the data subject about those recipients on request. Source
  • In Proximus (C-129/21) the Court of Justice held that a controller is, in principle, to communicate any rectification or erasure to each recipient. Source
  • California Civil Code 1798.105(c)(1) requires a business receiving a verifiable deletion request to notify service providers, contractors and third parties it sold or shared the data with, unless impossible or disproportionate. Source
  • Peng, Mathur and Narayanan found retracted datasets such as DukeMTMC and MS-Celeb-1M remained available and in use, and that derivatives raised their own issues. Source

Tell us what data you need

Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.

See if your company qualifies