FA-45221 / Data systems / Open access

Nested field resolution reuses the current object when a field is absent · case 01

Nested field resolution reuses the current object when a field is absent.

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

ROOT CAUSE

nested-field-path: Nested field resolution reuses the current object when a field is absent.

THE FAILURE

nested-field-path: Nested field resolution reuses the current object when a field is absent.

Unsuccessful approach: An empty object is not the null result for an absent path.

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: break
                value=value[segment]
            out.append(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	`[{'b': 1}]`	`[None]`	Failed
scalar intermediate	`[None]`	`[None]`	Passed
zero leaf	`[0]`	`[0]`	Passed
empty path	`[{'a': 1}]`	`[{'a': 1}]`	Passed
multiple rows	`[1, 2]`	`[1, 2]`	Passed

SHA-256 / 1f524fda5542410d76acdfb18715c280cdd218abd057660007230b027609fdc5

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={}; break
                value=value[segment]
            out.append(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]`	Failed
scalar intermediate	`[None]`	`[None]`	Passed
zero leaf	`[0]`	`[0]`	Passed
empty path	`[{'a': 1}]`	`[{'a': 1}]`	Passed
multiple rows	`[1, 2]`	`[1, 2]`	Passed

SHA-256 / 371e8158a1698754a845501b4ec4bc6909d9493789a289f13350c8506f617369

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 / 542da135ada9cb9a57b412e183eff5695b865cf6ca7ee5ed483f7848dec8d7ab