rowcove/mock-training-schema-drift

Mock training-record schema drift fixtures

Small, deliberately mixed-quality synthetic fixtures for checking JSONL, Parquet and Arrow IPC inspection or validation workflows. No real people, customer records, private files or model outputs are included.

The useful question is simple: does your checker reach the later file, and can it distinguish a schema match from a valid record? A successful first preview should not silently stand in for either check.

Open one sample without Python

These direct downloads contain the same three clean mock records:

• JSONL
• Parquet
• Arrow IPC

Open one in your existing local data viewer to inspect the fields and exact values. These small clean files are for trying file opening, not a performance benchmark or validation of the whole fixture suite. The ZIP below retains the counterexamples and contract for complete schema and record-level checks. The direct columnar files are byte-identical to their clean members in that existing ZIP. All remain CC0 mock data.

Start here

1. Download mock-schema-fixtures.zip from Files and versions and extract it.
2. Open the clean file in any of the three format directories.
3. Check every file in that directory, rather than only its first file.
4. Compare the findings with expected-results.json. Row positions in that manifest are one-based within each file.
5. Check stored values too: 03-null-quality deliberately has the expected declared columnar schema, but one value violates the example contract.

No particular desktop tool or paid product is required. Use the native readers in your inspection tool, or Python's json module and PyArrow. JSONL does not have an embedded Arrow file schema; the JSONL manifest therefore uses null for schema_issues, rather than claiming a declared-schema check passed.

What is in the pack?

Each directory contains four files, each with three records. The JSONL, Parquet and Arrow IPC files represent the same four logical cases. There are 12 logical records per format, not 36 independent training examples.

File stem	Intended case	Declared Parquet / Arrow schema check	Record-contract failures
00-clean	String ID, numeric quality, nested messages	Pass	None
01-integer-id	ID changes from string to integer	type:record_id	Rows 1, 2, 3
02-missing-quality	Required field omitted	missing:quality	Rows 1, 2, 3
03-null-quality	Expected schema, null value in row 2	Pass	Row 2

Expected totals for each format: four files, 12 records, seven records that fail the illustrative contract. For each columnar format, two files fail the declared-schema comparison. Every file is syntactically readable; these are contract and type failures, not intentionally corrupt binary files.

contract.json inside the ZIP describes the intended record shape:

• record_id: a non-null string.
• quality: a non-null numeric value; a boolean is not accepted as a number.
• messages: a list of objects whose role and content values are strings.

These are example requirements, not universal requirements for JSON Lines or a specific trainer. The Arrow fields are nullable. That is why a null value can have the expected declared type while failing the stricter record contract.

The integer-ID case includes values above JavaScript's safe integer boundary. Inspect with an exact integer-aware reader; parsing into a JavaScript Number can change the value before you compare records. This does not imply the integer itself is invalid in JSON or in an Arrow int64 column. Its type is wrong only for this example's string-ID contract.

Files outside the ZIP

• demo.jsonl: three clean records, used by the Hub's clean-preview config. The clean viewer preview does not include the negative cases in the ZIP.
• expected-results.json: all 12 format-file entries, expected failing rows, schema outcomes and SHA-256 digests for exact file verification.
• README.md: this dataset card.

The ZIP contains 12 data files and one contract file. Negative cases are packaged separately so automatic dataset loading does not try to reconcile intentionally incompatible schemas into one training split.

How it was made and checked

The RowCove team designed the cases with AI assistance and generated records programmatically from fixed mock text. PyArrow 23.0.1 wrote the Parquet and Arrow IPC files. Each file was reopened with its corresponding reader, decoded values were compared with the generated records, and schema and record results were checked against the table above. ZIP integrity and all manifest file hashes were verified.

For a runnable explanation of the underlying schema-versus-record distinction, see the team's JSONL / Parquet / Arrow shard walkthrough. The walkthrough uses a related smaller example; the four-case pack here adds the explicit null-value file and has its own expected-results manifest.

Intended use and limitations

Use these fixtures in tutorials, validator regression checks and manual inspection exercises. They are not meaningful model-training data, a representative production corpus, a performance benchmark or a privacy audit. The metadata split is named train only to make the clean preview compatible with ordinary dataset tooling.

Passing these cases does not prove support for all types, nested structures, encodings, compression codecs, missing-value policies or file sizes. It does not establish whole-dataset validity, anonymity, deduplication or suitability for any training pipeline. The pack is tiny and provides no GB/TB timing, memory or disk-usage evidence.

Attribution and license

Created by the RowCove team, developers of a commercial local data workspace. This resource is independently usable and contains no RowCove application source code. The generated fixtures and this card are offered under CC0 1.0.