Using multiple Field in the type annotations for the same field

[imneedle]

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 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 typing import Annotated

from sqlalchemy import inspect
from sqlmodel import SQLModel, Field


def IndexField() -> Field:
    return Field(index=True)


def UniqueField() -> Field:
    return Field(unique=True)


def ForeignKeyField(foreign_key: str) -> Field:
    return Field(foreign_key=foreign_key)


def PrimaryKeyField() -> Field:
    return Field(primary_key=True)


class Test(SQLModel, table=True):
    id: Annotated[int | None, PrimaryKeyField()]
    x: Annotated[int, UniqueField(), IndexField()]
    y: Annotated[int | None, ForeignKeyField("subtest.id"), IndexField()]


class SubTest(SQLModel, table=True):
    id: Annotated[int | None, PrimaryKeyField()]


mapper = inspect(Test)
for column in mapper.tables[0].columns:
    print(f"{column=!r}")
    print(f"{column.primary_key=}")
    print(f"{column.unique=}")
    print(f"{column.index=}")
    print(f"{column.foreign_keys=}")

Description

Hello. I am trying to set up my database using SQLModel.

Doing so, I am getting tired of some of the repetition when setting foreign_key, index or unique on the Field annotations.

I would like to be able to reach something like this:

from typing import Annotated

from sqlmodel import SQLModel

from .fields import PrimaryKeyField, IndexField, UniqueField, ForeignKeyField

class Test(SQLModel, table=True):
    id: Annotated[int | None, PrimaryKeyField()]
    x: Annotated[int, UniqueField(), IndexField()]
    y: Annotated[int | None, ForeignKeyField("subtest.id")]

And the fields.py field would look like:

from sqlmodel import Field


def IndexField() -> Field:
    return Field(index=True)


def UniqueField() -> Field:
    return Field(unique=True)


def ForeignKeyField(foreign_key: str) -> Field:
    return Field(foreign_key=foreign_key)


def PrimaryKeyField() -> Field:
    return Field(primary_key=True)

When testing out, I used sqlalchemy.inspect on the model, to see if the constraints were applied. The output shows that it didn't work:

from sqlalchemy import inspect

from .test import Test

mapper = inspect(Test)
for column in mapper.tables[0].columns:
    print(f"{column=!r}")
    print(f"{column.primary_key=}")
    print(f"{column.unique=}")
    print(f"{column.index=}")
    print(f"{column.foreign_keys=}")

Operating System

Linux

Operating System Details

No response

SQLModel Version

0.0.18

Python Version

Python 3.12.3

Additional Context

I would like to add that this composition of Field seems to work in Pydantic...

from typing import Annotated

from pydantic import Field, BaseModel


class Test(BaseModel):
    x: Annotated[int, Field(ge=0), Field(lt=100)]


print(Test.model_fields)

Which would output the following:

{'x': FieldInfo(annotation=int, required=True, metadata=[Ge(ge=0), Lt(lt=100)])}

Additionally, I tried using the same approach in SQLModel, and still no luck:

y: Annotated[int | None, Field(unique=True), Field(index=True), Field(foreign_key="subtest.id")]

[joachimhuet]

You should look into that thread: #52
When table=True annotations and therefore validation is deactivated.