Order of printed representation relies on __dict__, which has no reliable order in sqlalchemy

[brainbytes42]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the documentation, with the integrated search.
• I already searched in Google "How to X" and didn't find any information.
• I already read and followed all the tutorials in the docs and didn't find an answer.

Example Code

import platform

import pydantic
import sqlalchemy
import sqlmodel
from sqlmodel import Field, Session, SQLModel, create_engine, select

# enable custom __repr_args__
_sort_repr: bool = False

class PydanticHero(pydantic.BaseModel):
    id: int | None = None
    name: str
    secret_name: str
    age: int | None = None


hero = PydanticHero(name="Deadpond", secret_name="Dive Wilson")
print("Pure pydantic Model:             ", hero)

class Hero(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: int | None = None

    def __repr_args__(self) -> Sequence[tuple[str | None, Any]]:

        if _sort_repr:
            repr_args_dict = {k: v for k, v in super().__repr_args__()}

            sorted_repr_args = {k: repr_args_dict[k] for k in self.__pydantic_fields__.keys() if k in repr_args_dict}
            sorted_repr_args.update({k: v for k, v in repr_args_dict.items() if k not in sorted_repr_args})

            return [(k, v) for k, v in sorted_repr_args.items()]

        else:
            return super().__repr_args__()


engine = create_engine("sqlite:///:memory:", echo=True)

SQLModel.metadata.create_all(engine)

hero = Hero(name="Deadpond", secret_name="Dive Wilson")
print("Created in code / not from DB:   ", hero)

with Session(engine) as session:
    session.add(hero)
    session.commit()

with Session(engine) as session:
    hero = session.exec(select(Hero)).first()

    print("Default String:                  ", hero)

    _sort_repr = True
    print("Ordered by __pydantic_fields__:  ", hero)

    print()
    print(f"{hero.__dict__.keys()=}")
    print(f"{hero.__pydantic_fields__.keys()=}")
    print(f"{hero.__repr_args__()=}")
    print()
    print(f"{sqlmodel.__version__=}")
    print(f"{pydantic.__version__=}")
    print(f"{sqlalchemy.__version__=}")
    print(f"{platform.python_version()=}")

Description

When I print a Model, I expect the fields ordered the same as they are defined in my model - as it is in pydantic by default.
But the order seems quite random, as soon as SQLModel / SQAlchemy is concerned.

[I assume the issue being rooted at SQAlchemie's "dark magic", as you phrased it in som comment, but as the ordering isn't relevant there, but only here, where Pydantic-Behaviour is expected, I file this issue here.]

Operating System

Windows

Operating System Details

No response

Project Version

0.0.38

Python Version

3.14.0

Additional Context

There was a related Discussion in #542, but this ordering is correct here, as can be seen from the SQL-Echo.

CREATE TABLE hero (
	id INTEGER NOT NULL, 
	name VARCHAR NOT NULL, 
	secret_name VARCHAR NOT NULL, 
	age INTEGER, 
	PRIMARY KEY (id)
)

...

SELECT hero.id, hero.name, hero.secret_name, hero.age 
FROM hero

The output of my script is as follows (I removed the irrelevant parts from engine's echo and added comments):

# correct ordering
Pure pydantic Model:              id=None name='Deadpond' secret_name='Dive Wilson' age=None

# even here, the order is wrong (but at least consistent with the one below)
Created in code / not from DB:    name='Deadpond' secret_name='Dive Wilson' id=None age=None

# wrong order (not as defined in model) and correct order from custom __repr_args__
Default String:                   name='Deadpond' secret_name='Dive Wilson' id=1 age=None
Ordered by __pydantic_fields__:   id=1 name='Deadpond' secret_name='Dive Wilson' age=None

# some relevant datastructures from my debugging
hero.__dict__.keys()=dict_keys(['_sa_instance_state', 'name', 'secret_name', 'id', 'age'])
hero.__pydantic_fields__.keys()=dict_keys(['id', 'name', 'secret_name', 'age'])
hero.__repr_args__()=[('id', 1), ('name', 'Deadpond'), ('secret_name', 'Dive Wilson'), ('age', None)]

# versions
sqlmodel.__version__='0.0.38'
pydantic.__version__='2.13.4'
sqlalchemy.__version__='2.0.50'
platform.python_version()='3.14.0'

Pydantic uses dict for repr_args:
https://github.com/pydantic/pydantic/blob/cf50ed2ac36d1ee3ec942ad630af860f295eb3ec/pydantic/main.py#L1286-1300

... which in SQLModel is filtered, but not reordered:
https://github.com/fastapi/sqlmodel/blob/56f1dc3d69a6bf0085e03acd293a23d0196e6f02/sqlmodel/main.py#L859-865

SQLAlchemy gives no guarantees on dict order, at least as of 2019, but seems valid today:
sqlalchemy/sqlalchemy#4728 (comment)

=> May I suggest to add something like the __repr_args__-function I added to my Hero-model directly to the SQLModel-baseclass? As the filtering is already in place there, the ordering could go alongside, I think?

[sueun-dev]

I can reproduce this on current main (56f1dc3d) with SQLModel 0.0.38, Pydantic 2.13.4, SQLAlchemy 2.0.50. The exact default order varied for me (name, secret_name, age, id after a DB round trip), but it still wasn't the model field order.

The reason looks like what you found: Pydantic's BaseModel.__repr_args__() iterates self.__dict__.items(), and SQLModel's override only filters out _sa_* entries; it doesn't reorder the remaining args. Sorting that filtered result by self.__pydantic_fields__ gave me id, name, secret_name, age again. So yeah, this looks like a SQLModel-side repr ordering issue rather than SQL column ordering.

[delcenjo]

This is expected, and it comes from SQLAlchemy rather than from Pydantic/SQLModel directly.

For a table=True model the columns are instrumented attributes. SQLAlchemy writes them into the instance __dict__ as they are loaded or assigned, so after a query the key order in __dict__ reflects load order, not the field declaration order. Pydantic's default __repr_args__ iterates __dict__, which is why the order looks stable for an instance built in code but shuffles for one loaded from the database.

Ordering by the declared fields (like your _sort_repr branch) is the right approach. A compact version that doesn't need the toggle:

from typing import Any, Sequence


def __repr_args__(self) -> Sequence[tuple[str | None, Any]]:
    present = dict(super().__repr_args__())
    # declared-field order first, then anything else (relationships, etc.)
    ordered = [(k, present[k]) for k in type(self).model_fields if k in present]
    ordered += [(k, v) for k, v in present.items() if k not in type(self).model_fields]
    return ordered

If you want this for every model, put __repr_args__ on a shared base class that your table=True models inherit from. (model_fields is the public Pydantic v2 accessor; __pydantic_fields__ works too.)