`postgrest.types.JSONAdapter` is much slower than `TypeAdapter(JsonValue)`

[coroluca]

Describe the bug

Hi, I noticed that the JSON alias currently used by postgrest-py:

JSON = TypeAliasType(
    "JSON",
    "Union[None, bool, str, int, float, Sequence[JSON], Mapping[str, JSON]]",
)

is much slower (13x) than Pydantic's built-in JsonValue on the same payload.

Reproduction

import json
import statistics
import timeit

from postgrest.types import JSONAdapter
from pydantic import TypeAdapter
from pydantic.types import JsonValue

postgrest_json = JSONAdapter
json_value = TypeAdapter(JsonValue)

payload = json.dumps(
    [
        {
            "id": i,
            "name": f"doc-{i}",
            "labels": ["a", "b", "c"],
            "status": {"id": 1, "label": "Review", "done": False},
            "metadata": {"scores": [0.9, 0.8, 0.7], "flags": {"pinned": True, "archived": False}},
        }
        for i in range(1_000)
    ]
).encode()


def bench(label: str, stmt: str) -> float:
    ms = statistics.mean(timeit.repeat(stmt, number=1, repeat=5, globals=globals())) * 1000
    print(f"{label:24} {ms:8.2f} ms")
    return ms


print(f"payload_size={len(payload):,} bytes")
bench("postgrest TypeAliasType", "postgrest_json.validate_json(payload)")
bench("pydantic.JsonValue", "json_value.validate_json(payload)")
bench("json.loads", "json.loads(payload)")

On my machine this is the output:


payload_size=200,780 bytes
postgrest TypeAliasType     11.65 ms
pydantic.JsonValue           0.86 ms
json.loads                   0.76 ms

Steps to reproduce

No response

Library affected

postgrest

Library version

postgrest 2.29.0

Python version

3.14.0

[o-santi]

You are right. Even though both of them are still TypeAliasTypes, the pydantic one is much faster. I believe the reason to be that it adds discriminators to short circuit the Union matching.

However, I'm not sure if the fix is to rely on pydantic for this type. It is still slower than json.loads, which in itself is horribly slow, and other libraries like orjson are 100x faster than that. I just haven't found a relatively good parser that also has correct type information.

[shawnkitagawa]

Hi, I’d like to work on this issue if external contributions are welcome.

From what I understand, the current JSONAdapter is slower because the custom recursive JSON alias causes more expensive validation than Pydantic’s built-in JsonValue. I also saw the discussion that simply relying on JsonValue may not be the final ideal solution, especially if there are better parser/type-safety tradeoffs.

My plan is to investigate the current implementation, compare the existing behavior with TypeAdapter(JsonValue), and make a small focused PR if I can improve the adapter without changing unrelated files or release/changelog files. I can also add/update a focused test if appropriate.

Please let me know if this direction sounds okay.