Combining table fields into a single model field

[madduck]

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 SQLModel documentation, with the integrated search.
• I already searched in Google "How to X in SQLModel" and didn't find any information.
• I already searched using an independent engine "How to X in SQLModel" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to SQLModel but to Pydantic.
• I already checked if it is not related to SQLModel but to SQLAlchemy.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from pydantic import computed_field
from sqlmodel import SQLModel


class Foo(SQLModel, table=True):
    field1: int
    field2: int
    field3: int

    @computed_field
    @property
    def fields(self) -> list[int]:
        return [self.field1, self.field2, self.field3]

Description

The database I am dealing with is really badly designed, and I would like to hide some of the atrocities in my models. Take the above example… is it possible to somehow make that model read the field{1…3} columns from the database, but not actually expose them on the model? Make them private somehow, and let me provide my own accessor?

I am aware that I can use Pydantic to hide these fields from __repr__ and the schemata, but I'd also like to hide them from the language server, such that field{1…3} are never offered to the coder as possible attributes of instances of the class?

Operating System

Linux

Operating System Details

Debian unstable

SQLModel Version

0.0.27

Python Version

3.13.7

Additional Context

No response

[ShayanMuhammad-CS]

You can get most of the way there with sa_column to decouple the Python attribute name from the DB column name, plus computed_field for the derived accessor:

from sqlalchemy import Column, Integer
from sqlmodel import SQLModel, Field
from pydantic import computed_field


class Foo(SQLModel, table=True):
    field1_: int = Field(sa_column=Column("field1", Integer))
    field2_: int = Field(sa_column=Column("field2", Integer))
    field3_: int = Field(sa_column=Column("field3", Integer))

    @computed_field
    @property
    def fields(self) -> list[int]:
        return [self.field1_, self.field2_, self.field3_]

sa_column=Column("field1", ...) maps the attribute to the real (ugly) column name, so at least the Python-facing name can be whatever you want.

The part that's worth being upfront about: there's no way to make field1_/field2_/field3_ truly invisible to the language server the way a real private attribute would be. Both SQLAlchemy's mapper and Pydantic's model machinery need these to exist as ordinary class attributes to work at all — they have to be declared where the type checker can see them, so autocomplete will always be able to find them. A leading underscore is only a convention here, not enforcement (and a leading double underscore would trigger Python name-mangling and break both ORMs, so that's not an option either).

If you want the raw columns to be fully absent from what callers/IDEs see, the usual way out is a layer of indirection: keep the table model private to your data-access code (only that module ever imports it), and expose a separate plain (non-table=True) SQLModel/Pydantic model to the rest of the app that only defines fields, built via Foo.model_validate(row) or a small mapper function. That costs you an extra class and a mapping step, but it's the only way to actually remove field1..3 from the type surface everyone else works with, rather than just discouraging its use.

[madduck]

Many thanks for your elaborate and informative answer!