README.md

metadata

license: apache-2.0
pretty_name: Tabular Evolution Corpus
size_categories:
  - n<1K
tags:
  - schema-evolution
  - parquet
  - arrow
  - data-engineering
  - test-fixtures
  - tabular
configs:
  - config_name: default
    default: true
    data_files:
      - split: scenarios
        path: data/scenarios.parquet

Tabular Evolution Corpus

Source, generator and validator: github.com/AndreaBozzo/tabular-evolution-corpus. This card is the README.md of the Hugging Face dataset repository; the GitHub repository keeps its own README.

A small, deterministic corpus of Parquet datasets that change over time. Each scenario is one logical dataset at two or more versions, with a manifest that records what structurally changed and which row and value facts hold across each transition. Every fact is verified against the files.

The corpus records facts, not compatibility verdicts. Whether a change is acceptable is for the engine, table format or data contract under test to decide.

What the viewer shows

The viewer shows the catalog, data/scenarios.parquet, with one row per scenario (35 rows). The catalog is an index. The versioned fixture files it points to live in the same repository under fixtures/<scenario_id>/ (v0.parquet, v1.parquet, ..., scenario.json).

The configs block above deliberately restricts the viewer and load_dataset to the catalog. The fixture Parquet files have a different schema in every scenario and are not rows of one dataset. Without the explicit config, automatic data-file detection would try to load them as one.

Catalog columns

column	type	meaning
scenario_id	string	stable identifier; also the fixture directory name
title, description	string	what changes, stated as facts
category	string	additive, subtractive, numeric, nullability, representation, structural, temporal, edge
notes	list	caveats, e.g. differences that exist only in the stored Arrow schema
tags	list	free-form, kebab-case
row_identity	list	columns that identify a row in every version; empty means rows are identified by position
version_count, version_ids, row_counts	int64, list, list	versions in order
mutation_count, mutation_kinds	int64, list	structural changes across all transitions
paths	list	field paths touched by a mutation or a value change
value_change_relations	list	how changed values relate (nearest_float64, utf8_encoded, ...)
schema_changed, values_changed, parquet_schema_changed	bool	quick filters
base_file, final_file, manifest_path	string	repository-relative paths
base_schema_json, final_schema_json, transitions_json	string	JSON; full detail is in scenario.json
base_fingerprint, final_fingerprint	string	logical fingerprints (schema + values + row order)

Nested manifest structures are JSON strings because their shape depends on the mutation kind. Every other column is a scalar or a list of scalars.

Usage

from datasets import load_dataset

catalog = load_dataset("AndreaBozzo/tabular-evolution-corpus", split="scenarios")

To get the fixtures, download the repository files:

from huggingface_hub import snapshot_download

root = snapshot_download("AndreaBozzo/tabular-evolution-corpus", repo_type="dataset")
# root/fixtures/<scenario_id>/{v0.parquet, v1.parquet, scenario.json}

Every corpus release is a tag, both here and on GitHub. Pass revision="v0.2.0" to either call to get exactly that release. A released tag is never moved, and a changed corpus gets a new release.

-- DuckDB
SELECT scenario_id, mutation_kinds, row_counts
FROM read_parquet('hf://datasets/AndreaBozzo/tabular-evolution-corpus/data/scenarios.parquet')
WHERE category = 'numeric';

Dataset structure

data/scenarios.parquet          catalog (this viewer)
fixtures/<scenario_id>/         one directory per scenario
    v0.parquet, v1.parquet ...  versions, 0-8 rows each
    scenario.json               manifest (JSON Schema: schema/scenario.schema.json)
schema/scenario.schema.json
SHA256SUMS

Creation

All data is synthetic, written by the generator in the source repository with a pinned PyArrow Parquet writer (uncompressed, format 2.6, one row group). Values are chosen to expose boundaries: NaN, infinities, -0.0, 2^53 + 1, int and decimal extremes, composed vs decomposed Unicode, empty strings, nested nulls, pre-epoch timestamps, timestamps at both ends of the nanosecond range. Regeneration is logically reproducible, and byte-reproducible with the same PyArrow version.

Intended use and limitations

Intended as test input for ingestion frameworks, dataframe libraries, query engines, lakehouse tooling, schema registries, contract validators and profilers. It is not training data, not a performance benchmark, and not a conformance suite for Arrow or Parquet (see apache/parquet-testing and the Arrow integration tests for those). Corpus 0.2.0 covers Parquet only and 35 scenarios. Nested evolution covers structs, lists and maps; datasets are keyed or identified by row position.

One writer. Every file is written by a single pinned Parquet writer (PyArrow / Arrow C++, recorded in each file's created_by). The scenarios vary the data, not the writer. Differences that exist only in the Arrow schema stored in the file (large_string, dictionary encoding) are flagged in each manifest, because readers that ignore that schema see no change. Fixtures from other writers are planned but not included.

License

Apache-2.0. No personal data: every name, address and e-mail in the fixtures is invented or a well-known public name used as a placeholder.