FA-45231 / Data systems / Open access

Nested path extraction converts valid falsy leaves to null · case 01

Nested path extraction converts valid falsy leaves to null.

Verified by executionVariant 1 · 7 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

nested-field-path: Nested path extraction converts valid falsy leaves to null.

THE FAILURE

nested-field-path: Nested path extraction converts valid falsy leaves to null.

Unsuccessful approach: An explicit zero remains a valid leaf.

Case contract

Resolve an explicit sequence of field path segments against each row dictionary. Dots inside a segment are literal characters; empty path returns the whole row. A missing segment, non-dictionary intermediate, or null intermediate yields None; falsy leaf values remain present.

Why this case matters

A bounded deterministic data engine model makes representation and changelog faults reproducible.

1 / The failure

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(d):
    try:
        rows,path=d
        out=[]
        for row in rows:
            value=row
            for segment in path:
                if not isinstance(value,dict): value=None; break
                if segment not in value: value=None; break
                value=value[segment]
            out.append(value or None)
        return out
    except (IndexError, KeyError, ValueError, StopIteration) as exc:
        return {"representation_error": type(exc).__name__}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('literal dotted field', solve([[{'a.b': 1, 'a': {'b': 2}}], ['a.b']]), [1])
    check('nested homonym', solve([[{'a': {'b': 1}, 'b': 2}], ['a', 'b']]), [1])
    check('missing segment', solve([[{'a': {'b': 1}}], ['a', 'z']]), [None])
    check('scalar intermediate', solve([[{'a': 1}], ['a', 'b']]), [None])
    check('zero leaf', solve([[{'a': 0}], ['a']]), [0])
    check('empty path', solve([[{'a': 1}], []]), [{'a': 1}])
    check('multiple rows', solve([[{'a': 1}, {'a': 2}], ['a']]), [1, 2])
elif N == 2:
    check('literal dotted field', solve([[{'a.b': 2, 'a': {'b': 3}}], ['a.b']]), [2])
    check('nested homonym', solve([[{'a': {'b': 2}, 'b': 3}], ['a', 'b']]), [2])
    check('missing segment', solve([[{'a': {'b': 2}}], ['a', 'z']]), [None])
    check('scalar intermediate', solve([[{'a': 2}], ['a', 'b']]), [None])
    check('zero leaf', solve([[{'a': 0}], ['a']]), [0])
    check('empty path', solve([[{'a': 2}], []]), [{'a': 2}])
    check('multiple rows', solve([[{'a': 2}, {'a': 3}], ['a']]), [2, 3])
elif N == 3:
    check('literal dotted field', solve([[{'a.b': 3, 'a': {'b': 4}}], ['a.b']]), [3])
    check('nested homonym', solve([[{'a': {'b': 3}, 'b': 4}], ['a', 'b']]), [3])
    check('missing segment', solve([[{'a': {'b': 3}}], ['a', 'z']]), [None])
    check('scalar intermediate', solve([[{'a': 3}], ['a', 'b']]), [None])
    check('zero leaf', solve([[{'a': 0}], ['a']]), [0])
    check('empty path', solve([[{'a': 3}], []]), [{'a': 3}])
    check('multiple rows', solve([[{'a': 3}, {'a': 4}], ['a']]), [3, 4])
elif N == 4:
    check('literal dotted field', solve([[{'a.b': 4, 'a': {'b': 5}}], ['a.b']]), [4])
    check('nested homonym', solve([[{'a': {'b': 4}, 'b': 5}], ['a', 'b']]), [4])
    check('missing segment', solve([[{'a': {'b': 4}}], ['a', 'z']]), [None])
    check('scalar intermediate', solve([[{'a': 4}], ['a', 'b']]), [None])
    check('zero leaf', solve([[{'a': 0}], ['a']]), [0])
    check('empty path', solve([[{'a': 4}], []]), [{'a': 4}])
    check('multiple rows', solve([[{'a': 4}, {'a': 5}], ['a']]), [4, 5])
elif N == 5:
    check('literal dotted field', solve([[{'a.b': 5, 'a': {'b': 6}}], ['a.b']]), [5])
    check('nested homonym', solve([[{'a': {'b': 5}, 'b': 6}], ['a', 'b']]), [5])
    check('missing segment', solve([[{'a': {'b': 5}}], ['a', 'z']]), [None])
    check('scalar intermediate', solve([[{'a': 5}], ['a', 'b']]), [None])
    check('zero leaf', solve([[{'a': 0}], ['a']]), [0])
    check('empty path', solve([[{'a': 5}], []]), [{'a': 5}])
    check('multiple rows', solve([[{'a': 5}, {'a': 6}], ['a']]), [5, 6])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
literal dotted field	`[1]`	`[1]`	Passed
nested homonym	`[1]`	`[1]`	Passed
missing segment	`[None]`	`[None]`	Passed
scalar intermediate	`[None]`	`[None]`	Passed
zero leaf	`[None]`	`[0]`	Failed
empty path	`[{'a': 1}]`	`[{'a': 1}]`	Passed
multiple rows	`[1, 2]`	`[1, 2]`	Passed

SHA-256 / 773a888705fcc6d72be3ce1806496e6bdef9d4f4fe759d5e1cf5a9fe806527ed

2 / The unsuccessful fix

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(d):
    try:
        rows,path=d
        out=[]
        for row in rows:
            value=row
            for segment in path:
                if not isinstance(value,dict): value=None; break
                if segment not in value: value=None; break
                value=value[segment]
            out.append(None if value==0 else value)
        return out
    except (IndexError, KeyError, ValueError, StopIteration) as exc:
        return {"representation_error": type(exc).__name__}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('literal dotted field', solve([[{'a.b': 1, 'a': {'b': 2}}], ['a.b']]), [1])
    check('nested homonym', solve([[{'a': {'b': 1}, 'b': 2}], ['a', 'b']]), [1])
    check('missing segment', solve([[{'a': {'b': 1}}], ['a', 'z']]), [None])
    check('scalar intermediate', solve([[{'a': 1}], ['a', 'b']]), [None])
    check('zero leaf', solve([[{'a': 0}], ['a']]), [0])
    check('empty path', solve([[{'a': 1}], []]), [{'a': 1}])
    check('multiple rows', solve([[{'a': 1}, {'a': 2}], ['a']]), [1, 2])
elif N == 2:
    check('literal dotted field', solve([[{'a.b': 2, 'a': {'b': 3}}], ['a.b']]), [2])
    check('nested homonym', solve([[{'a': {'b': 2}, 'b': 3}], ['a', 'b']]), [2])
    check('missing segment', solve([[{'a': {'b': 2}}], ['a', 'z']]), [None])
    check('scalar intermediate', solve([[{'a': 2}], ['a', 'b']]), [None])
    check('zero leaf', solve([[{'a': 0}], ['a']]), [0])
    check('empty path', solve([[{'a': 2}], []]), [{'a': 2}])
    check('multiple rows', solve([[{'a': 2}, {'a': 3}], ['a']]), [2, 3])
elif N == 3:
    check('literal dotted field', solve([[{'a.b': 3, 'a': {'b': 4}}], ['a.b']]), [3])
    check('nested homonym', solve([[{'a': {'b': 3}, 'b': 4}], ['a', 'b']]), [3])
    check('missing segment', solve([[{'a': {'b': 3}}], ['a', 'z']]), [None])
    check('scalar intermediate', solve([[{'a': 3}], ['a', 'b']]), [None])
    check('zero leaf', solve([[{'a': 0}], ['a']]), [0])
    check('empty path', solve([[{'a': 3}], []]), [{'a': 3}])
    check('multiple rows', solve([[{'a': 3}, {'a': 4}], ['a']]), [3, 4])
elif N == 4:
    check('literal dotted field', solve([[{'a.b': 4, 'a': {'b': 5}}], ['a.b']]), [4])
    check('nested homonym', solve([[{'a': {'b': 4}, 'b': 5}], ['a', 'b']]), [4])
    check('missing segment', solve([[{'a': {'b': 4}}], ['a', 'z']]), [None])
    check('scalar intermediate', solve([[{'a': 4}], ['a', 'b']]), [None])
    check('zero leaf', solve([[{'a': 0}], ['a']]), [0])
    check('empty path', solve([[{'a': 4}], []]), [{'a': 4}])
    check('multiple rows', solve([[{'a': 4}, {'a': 5}], ['a']]), [4, 5])
elif N == 5:
    check('literal dotted field', solve([[{'a.b': 5, 'a': {'b': 6}}], ['a.b']]), [5])
    check('nested homonym', solve([[{'a': {'b': 5}, 'b': 6}], ['a', 'b']]), [5])
    check('missing segment', solve([[{'a': {'b': 5}}], ['a', 'z']]), [None])
    check('scalar intermediate', solve([[{'a': 5}], ['a', 'b']]), [None])
    check('zero leaf', solve([[{'a': 0}], ['a']]), [0])
    check('empty path', solve([[{'a': 5}], []]), [{'a': 5}])
    check('multiple rows', solve([[{'a': 5}, {'a': 6}], ['a']]), [5, 6])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
literal dotted field	`[1]`	`[1]`	Passed
nested homonym	`[1]`	`[1]`	Passed
missing segment	`[None]`	`[None]`	Passed
scalar intermediate	`[None]`	`[None]`	Passed
zero leaf	`[None]`	`[0]`	Failed
empty path	`[{'a': 1}]`	`[{'a': 1}]`	Passed
multiple rows	`[1, 2]`	`[1, 2]`	Passed

SHA-256 / a032898f6447ba0039ca813b0146c434cdeea57d18a1c23f51b47a0c5b636b03

HELD IN THE MEMBER ARCHIVE

The verified repair and its recorded checks are member-only.

This mechanism has 7 recorded checks per implementation. The open-access tier publishes the failure and the unsuccessful fix; the repaired source that passes every check, and the observations that prove it, are available to members.

Every case sharing this mechanism uses the same contract and the same repair, so this one record is held back for all of them.

Member access is invitation-based. Sign in with your invited account to inspect the repair.

Verification & scope

Offline stipulated semantics over valid small inputs; no performance, concurrency, or production-engine conformance claim. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:44:20.133078+00:00.

Case digest / 92d29451bd735e8409d33d19a295bc241dffa3190fb2a8dad942a309dd1e0d4f