Identifiers change after opening
Software treats a column as numeric and removes leading zeros. Return to the raw export, require text for the key and check joins. Reformatting an already altered value may not reconstruct the original identifier.
In-depth practical guides
Connect source file, dates, schema and transformations: retain data that can be located, compared and reused without confusing an update, correction or change of scope.
Updated :

AI-generated illustration
A link to a changing database does not identify the data actually used. Corrections may revise old series, exports may lose leading zeros and new columns may change the meaning of a total. A useful version explains the starting material and processing path. The aim is reproducibility of the described work, not a universal guarantee of source quality.
Name producer, dataset, territory, population, period and filters. Separate observation, publication and download dates. An export received today may describe an old period. State the question and exclusions important to interpretation.
Record URL or public parameters, retrieval date and received file when permitted. Assign a version identifier and compute a file digest. A digest helps distinguish files; it does not establish value accuracy. Keep license information with the version.
Document fields, types, units, keys and missing values. For CSV, inspect delimiter, encoding, quotes and line breaks in the actual export. Preserve identifiers requiring leading zeros as text. Distinguish zero, missing and not-applicable values.
Record filtering, normalization, joins, conversions and deduplication rules in order. Separate raw input from prepared output. Retain join keys and unresolved cases. Similar names alone do not justify merging entities. Document choices instead of hiding them in the final file.
Measure added, removed and changed rows using a stable key where available. Also inspect structure, units and definitions. Row-count changes do not establish changes in the underlying phenomenon: filters, coverage or producer revisions may explain them.
Associate the result with its source version, steps and limits. Check links leading back to the producer and context. Plan a new collection with comparison criteria. Retain an older version separately when it supports a published conclusion, respecting conditions and the data it contains.
Reading workshop
The DEMO dataset is fictional. Its versions separate historical analysis from analysis using corrected data.
Fictional data and records for learning: none of these results comes from a live service query.
Both files contain the same key and period. The fictional producer publishes a correction note. A later catalogue-record edit leaves the CSV unchanged.
If the table exceeds the screen, scroll horizontally; arrow keys work when the region is focused.
| Fictional state | Available record | What changes | Use to disclose |
|---|---|---|---|
| v1 available in April | Value 80 for the selected key | Published state before correction | To describe what was accessible in April, cite v1. |
| v2 published in June | Corrected value 82 and revision note | Past observation corrected, not a new event | For revised analysis, cite v2 and disclose the correction. |
| Record edited after v2 | Description clarified, CSV unchanged in this case | Metadata only | Do not infer a new value from the record date. |
| Both analyses retained | Historical result with v1; revised result with v2 | Time-related question and source version | Do not silently mix versions. |
Open each proposition to compare its diagnosis. More checks may still be needed.
No. The old version may be needed to understand the conclusion published then.
Yes. Separate what was known in April from June’s revised analysis; link outputs to their input.
No. It concerns bytes compared with a reference, not whether a value is accurate or representative.
Dataset: DEMO; key and period unchanged v1: available in April; value=80 v2: published in June; corrected value=82 Reason: documented correction by fictional producer Later record: description only, CSV unchanged Outputs: historical linked to v1; revised linked to v2
The record keeps both analytical questions. Hashes identify the files used without making a retained version a true version.
Software treats a column as numeric and removes leading zeros. Return to the raw export, require text for the key and check joins. Reformatting an already altered value may not reconstruct the original identifier.
The new file also replaces earlier values. Compare by period and key, retain both versions and read producer notes. Separate revised observations from newly added ones before describing a trend.
Coverage now includes more territories or categories. Compare the common scope, then describe the extension separately. Record field changes and missing values rather than assuming every row is comparable.
Fictional example: A changes from 10 to 11, B disappears and C arrives. With id as key, the report counts one added key, one removed key and one modified shared record. A new column is listed separately; no previous value is invented. Reordering alone produces no modification.
Worked exercise
Fictional example: the values and documents teach the method and do not describe a real organisation.
Keys are unique, values additive and the dictionary unchanged. Nothing is deleted; “absent” means no such key in that version.
If the table exceeds the screen, scroll horizontally; arrow keys work when the region is focused.
| Key | Version V1 | Version V2 |
|---|---|---|
| A | 10 | 10 |
| B | 20 | 25 |
| C | Absent | 5 |
V1 totals 30 and V2 40: +10. On shared keys, B's revision explains +5; new key C adds +5. A is unchanged. The total's 33.33% rise should not be attributed entirely to growth among existing objects.
If units or definitions change in V2, pause this decomposition until comparability is checked.
Keep exports and hashes, dictionaries, added/changed keys and reconciliation formula.
Keep versions needed for the work and published conclusions under a defined retention rule. Avoid purposeless copies and respect storage and reuse conditions.
No. It identifies file content and helps detect a change; it does not validate provenance, interpretation or values.
Check keys, context and namesakes first. A matching rule must handle ambiguous cases and record merges.
Identify the version and relevant correction, separating the revised result from the previously published one. Do not present a revision as a new observation.
Two rows with the same identifier make matching ambiguous. Check their grain, period and origin, then define a compound key if needed. Do not remove a row before establishing whether it is a duplicate or a separate observation.
The file, its origin, its date, its hash and the useful documentation. Adding the processing rules and the reference of the products results facilitates subsequent reproduction and comparison.
DOCUMENTED REFERENCE
W3C PROV-O describes how documents or data were produced. Arrows follow property direction, not a left-to-right timeline. E0, A and E1 are teaching labels, not real resources.
| Reference | Value or form | What it identifies |
|---|---|---|
| prov:Entity | Data/document in a described state | Entity represents data or documents in a described state. Distinguish versions; a changing URL alone is insufficient. |
| prov:Activity | Process over time | Activity is a process over time acting on entities, not its output object. |
| prov:Agent | Person, organization or software agent | Agent bears responsibility. wasAttributedTo links entity to agent; wasAssociatedWith links activity to agent, not proof of licensing or exhaustive legal responsibility. |
| prov:used | Activity → Entity | used goes activity to entity: A uses E0. |
| prov:wasGeneratedBy | Entity → Activity | wasGeneratedBy goes output entity to activity: E1 was generated by A, not a version-to-version relation. |
| prov:wasDerivedFrom | Entity → Entity | wasDerivedFrom goes result entity to source entity; it does not provide formula, weights or fidelity proof. |
| prov:wasRevisionOf | Entity → Entity | Revision is a specific derivation retaining substantial original content; citing a document is not necessarily revising it. |
| prov:wasQuotedFrom | Entity → Entity | A passage is repeated from a larger source. Retain its exact wording and location; the relation alone does not locate the words. |
Four fictional cases show why a link must describe the actual transformation. The result is the subject of each relation; its source or agent is on the right.
quote → prov:wasQuotedFrom → source-v1
A passage is repeated from a larger source. Retain its exact wording and location; the relation alone does not locate the words.
translation → prov:wasDerivedFrom → source-v1
The translation is a new derived entity. Retain source and target languages, version and fidelity checks; translated text must remain distinct from the original passage.
source-v2 → prov:wasRevisionOf → source-v1
The corrected version retains substantial content from its predecessor. Keep both states and the changes; this relation does not determine which version is accurate.
analysis → prov:wasAttributedTo → editor
The entity is attributed to an agent. For responsibility for a process, use Activity → prov:wasAssociatedWith → Agent. Attribution does not establish reuse rights.
Provenance describes an asserted chain. It makes neither a translation independent evidence nor attribution validation of the content.
Describe known inputs, output, activity and agent without inventing gaps. Provenance records a transformation assertion, not automatic correctness, rights or authenticity. Preserve versions and source references.
No. Exact versions, filters, formula, parameters and missing-value conventions are also needed; one source can support different methods.
Documentation consulted on .
DOCUMENTED REFERENCE
Adding received lengths can conceal an incomplete transfer: overlap counts the same positions repeatedly. Compute the union of the intervals and compare it with the intended representation. This geometric check remains separate from byte identity and provenance.
| Reference | Value or form | What it identifies |
|---|---|---|
| 0-399,300-599,700-999 | Σ = 1000; ∪ = 900 | For L = 1,000, fragments 0–399, 300–599 and 700–999 total 1,000 declared bytes. Their union covers only 900 positions: 600–699 is missing and 100 byte receipts are redundant. |
| 0-499,500-999 | ∪ = 1000 | Adjacent intervals merge without a gap: 0–499 and 500–999 cover 1,000 positions. Receiving the same byte three times adds two redundant receipts, rather than two distinct overlapping positions. |
| Content-Range | first ≤ last < L | A response Content-Range must have an end at least equal to its start; a known total length must be strictly greater than that end. An unknown length marked * cannot establish full coverage. |
| ETag | strong validator | Fragments must belong to the same representation. RFC 9111 requires a shared strong validator and the HTTP recombination conditions when a cache combines partial responses. A matching URL or length does not replace this check. |
| If-Range | strong comparison | If-Range uses strong ETag comparison. A client must not send a weak ETag in it; a failed condition causes Range to be ignored and requests the full transfer. A date is allowed only under HTTP’s strong-validator conditions. |
Original teaching examples; no measurement of a real server.
L: integer from 1 to 1,000,000,000,000. Enter 1–20 inclusive a-b intervals, one per line, within the representation. Blank lines are ignored; spaces and tabs around lines are allowed. At most 2,000 characters; no HTTP header.
Calculated locally in your browser; entered data is neither transmitted nor stored.
Calculation updated.
Arithmetic coverage only: representation identity and byte integrity still require verification.
| Inclusive interval | Length |
|---|---|
| 0–599 | 600 |
| 700–999 | 300 |
| Inclusive interval | Length |
|---|---|
| 600–699 | 100 |
sum = Σ(lastᵢ − firstᵢ + 1) unique = |∪ intervals| redundant = sum − unique missing = L − unique
| L | Declared fragments (a-b, one per line) | Sum of declared lengths | Distinct covered positions | Redundant byte receipts | Missing positions | Missing intervals |
|---|---|---|---|---|---|---|
| 1000 | 0–399; 300–599; 700–999 | 1000 | 900 | 100 | 100 | 600–699 |
| 1000 | 0–499; 500–999 | 1000 | 1000 | 0 | 0 | None |
| 1000 | 0–999; 0–999 | 2000 | 1000 | 1000 | 0 | None |
| 10 | 0–0; 0–0; 0–0 | 3 | 1 | 2 | 9 | 1–9 |
| 10 | 9–9; 0–0 | 2 | 2 | 0 | 8 | 1–8 |
| 10 | 2–7; 3–4 | 8 | 6 | 2 | 4 | 0–1; 8–9 |
| 1 | 0–0 | 1 | 1 | 0 | 0 | None |
| 1000000000000 | 0–999999999998; 999999999999–999999999999 | 1000000000000 | 1000000000000 | 0 | 0 | None |
Coverage assumes declared positions in one representation. This tool reads no files and checks no ETag, Content-Encoding, cache or digest. It does not establish equal bytes within an overlap. Complete coverage is not an integrity certificate.
No. An ETag is an HTTP validator, not necessarily a cryptographic digest or an author’s signature. Also check the variant, lengths and actual received bytes; record provenance and integrity checks separately.
Documentation consulted on .
DOCUMENTED REFERENCE
A JSON Patch list is evaluated in order. Each path addresses the document produced by previous operations, not a permanent snapshot of the initial document. These nine original walkthroughs show calculation states and stopping conditions.
| Reference | Value or form | What it identifies |
|---|---|---|
| add | insert / replace | add inserts at an array index and shifts later elements; a final hyphen appends after the last element. In an object, add also replaces an existing member. The parent container must exist. |
| remove / replace | existing target | remove and replace require an existing target. Removing an array element shifts higher indexes left, so the same path can subsequently select a different element. |
| move | remove → add | move first removes the from value, then adds it at path in the modified document. Moving to a later array position requires using the resulting indexes. Moving into a proper descendant is forbidden. |
| copy / test | value / equality | copy adds the referenced value without linking both locations. test compares a value using JSON rules, writes nothing and stops evaluation on failure. Object member order is not significant for equality. |
| HTTP PATCH | atomic | An error stops the sequence. In HTTP PATCH, all changes must be applied atomically: a failed patch applies no changes. The reader’s intermediate states explain the calculation; they are not committed writes. |
| Content-Type | patch format | Content-Type distinguishes application/json-patch+json from application/merge-patch+json. PATCH support alone does not guarantee both formats. An HTTP precondition such as If-Match can prevent an update against a stale version; test does not automatically replace it. |
Original teaching examples; no real document is modified.
Choose a walkthrough and step. Each operation addresses the preceding result. On failure, the reader shows the initial target again to illustrate HTTP atomicity; later operations are not executed.
Predefined walkthrough reader; no arbitrary patch is executed here.
Initial state · 0 / 2
{
"items": [
"A",
"B",
"C"
]
}nullNo operation at this step.
{
"items": [
"A",
"B",
"C"
]
}Initial state
No operation at this step.
{
"items": [
"A",
"B",
"C"
]
}Intermediate state, not committed
{
"op": "remove",
"path": "/items/0"
}{
"items": [
"B",
"C"
]
}Sequence succeeded
{
"op": "replace",
"path": "/items/1",
"value": "X"
}{
"items": [
"B",
"X"
]
}Initial state
No operation at this step.
[
"A",
"C"
]Intermediate state, not committed
{
"op": "add",
"path": "/1",
"value": "B"
}[
"A",
"B",
"C"
]Sequence succeeded
{
"op": "add",
"path": "/-",
"value": "D"
}[
"A",
"B",
"C",
"D"
]Initial state
No operation at this step.
{
"note": "old",
"keep": true
}Intermediate state, not committed
{
"op": "replace",
"path": "/note",
"value": null
}{
"note": null,
"keep": true
}Sequence succeeded
{
"op": "remove",
"path": "/note"
}{
"keep": true
}Initial state
No operation at this step.
{
"source": {
"n": 1
}
}Intermediate state, not committed
{
"op": "copy",
"from": "/source",
"path": "/backup"
}{
"source": {
"n": 1
},
"backup": {
"n": 1
}
}Sequence succeeded
{
"op": "replace",
"path": "/source/n",
"value": 2
}{
"source": {
"n": 2
},
"backup": {
"n": 1
}
}Initial state
No operation at this step.
[
"A",
"B",
"C",
"D"
]Sequence succeeded
{
"op": "move",
"from": "/1",
"path": "/3"
}[
"A",
"C",
"D",
"B"
]Initial state
No operation at this step.
{
"rev": 1,
"label": "A"
}Intermediate state, not committed
{
"op": "replace",
"path": "/label",
"value": "B"
}{
"rev": 1,
"label": "B"
}Failure: HTTP PATCH applies no changes
{
"op": "test",
"path": "/rev",
"value": 2
}{
"rev": 1,
"label": "A"
}Not executed after failure
{
"op": "add",
"path": "/extra",
"value": true
}{
"rev": 1,
"label": "A"
}Initial state
No operation at this step.
{
"a": []
}Failure: HTTP PATCH applies no changes
{
"op": "add",
"path": "/missing/x",
"value": 1
}{
"a": []
}Initial state
No operation at this step.
{
"a/b": {
"~key": 1
}
}Intermediate state, not committed
{
"op": "test",
"path": "/a~1b/~0key",
"value": 1
}{
"a/b": {
"~key": 1
}
}Sequence succeeded
{
"op": "add",
"path": "",
"value": [
"root"
]
}[
"root"
]Initial state
No operation at this step.
{
"x": 1
}Sequence succeeded
{
"op": "add",
"path": "/x",
"value": 2
}{
"x": 2
}This reader presents documented walkthroughs, not a universal JSON Patch executor. It contacts no server and predicts no response code. The atomicity shown belongs to HTTP PATCH; a local library must document its own error and mutation behavior.
No. The media type and resource contract are needed. Accept-Patch can advertise accepted formats. Neither the method name nor a local example proves that a remote API supports a format or permits the update.
Documentation consulted on .
DOCUMENTED REFERENCE
SemVer 2.0.0 defines syntax and precedence for software versions with a declared public API. Treating them as plain strings or decimal numbers gives incorrect results. A dataset date or tag name does not automatically adopt this contract.
| Reference | Value or form | What it identifies |
|---|---|---|
| MAJOR.MINOR.PATCH | 0 | [1-9][0-9]* | The core contains three non-negative integers: MAJOR.MINOR.PATCH. Leading zeroes are forbidden except for 0 itself. The tag v1.2.3 may identify a release, but its full string is not a strict SemVer version. |
| 1.9.0 / 1.10.0 | numeric | Core numbers are compared numerically, left to right. Thus 1.9.0 precedes 1.10.0. SemVer sets no numeric length limit: the tool compares digits without floating-point conversion. |
| -alpha.1 | pre-release | With equal cores, a prerelease precedes the normal version. Its dot-separated identifiers must be nonempty. A purely numeric identifier forbids leading zeroes; an identifier with a letter or hyphen follows a different case. |
| -2 / -alpha | numeric < non-numeric | Numeric identifiers compare numerically; other identifiers use ASCII order. Numeric identifiers precede non-numeric ones. When all shared identifiers are equal, the prerelease with more identifiers has higher precedence. |
| +001 | ignored in precedence | Metadata after + never affects precedence. Unlike numeric prerelease identifiers, it may contain 001. Different strings can therefore have equal precedence without identifying equal files or interchangeable artifacts. |
Original teaching examples; no real release is evaluated.
Two strict SemVer 2.0.0 versions, at most 256 ASCII characters each. No spaces, v prefix or constraint operators. Numeric identifiers are compared exactly, without rounding.
Calculated locally in your browser; input is neither transmitted nor stored.
A precedes B in SemVer order.
1.9.0 < 1.10.0
First decisive criterion : MINOR
| Component | Version A | Version B |
|---|---|---|
| MAJOR | 1 | 1 |
| MINOR | 9 | 10 |
| PATCH | 0 | 0 |
| Prerelease | None | None |
| Build metadata | None | None |
| Version A | < / = / > | Version B | First decisive criterion |
|---|---|---|---|
| 1.9.0 | < | 1.10.0 | MINOR |
| 2.0.0 | > | 1.99.99 | MAJOR |
| 1.0.9 | < | 1.0.10 | PATCH |
| 1.2.3-rc.9 | < | 1.2.3 | Prerelease versus normal version |
| 1.2.3-alpha.2 | < | 1.2.3-alpha.11 | Prerelease identifier |
| 1.2.3-9 | < | 1.2.3-alpha | Prerelease identifier |
| 1.2.3-alpha | < | 1.2.3-alpha.0 | Prerelease identifier count |
| 1.2.3-Beta | < | 1.2.3-alpha | Prerelease identifier |
| 1.2.3+linux.001 | = | 1.2.3+windows.002 | Metadata excluded from precedence |
| 9007199254740992.0.0 | < | 9007199254740993.0.0 | MAJOR |
| Input | Diagnosis |
|---|---|
| 1.2.3 | Valid |
| 0.0.0-0 | Valid |
| 1.2.3+001 | Valid |
| 1.2.3-01a | Valid |
| 1.2.3-- | Valid |
| v1.2.3 | Invalid |
| 1.02.3 | Invalid |
| 1.2.3-01 | Invalid |
| 1.2.3-alpha..1 | Invalid |
| 1.2.3+ | Invalid |
Original interpretation and examples based on SemVer 2.0.0, originally authored by Tom Preston-Werner; reference text under CC BY 3.0. SemVer 2.0.0 · CC BY 3.0
The comparator checks syntax and precedence, not release notes, content, security or actual compatibility. It handles no dependency constraints, npm ranges, Python versions or Debian versions. The 256-character limit belongs to this form, not to SemVer.
Not automatically. Keep the full string and artifact reference: 1.2.3+linux and 1.2.3+windows have equal precedence, but metadata can distinguish builds. A digest and publication contract remain separate checks.
Documentation consulted on .
DEEPER READING / PRACTICE
A public file is replaced at the same location. The versioning should allow you to recover the state used in a calculation and understand the subsequent changes.
Updated on .
Keep file, date, source, hash and scheme. Compare lines, columns, definitions and values before attributing differences to an evolution of the measured phenomenon.
A new download date does not necessarily mean a new content. A structure change can make a brutal comparison difficult to interpret.
The version journal combines status, hash, change and effect on the analysis. The calculations explicitly cite the version used.