No overload variant of "select" matches argument types

[StefanBrand]

First Check

• I added a very descriptive title to this issue.
• I used the GitHub search to find a similar issue 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 Optional

from geoalchemy2.types import Geometry
from sqlmodel import Column, Field, SQLModel, cast, select


class Country(SQLModel, table=True):
 class Config:
 arbitrary_types_allowed = True

 id: Optional[int] = Field(default=None, primary_key=True)
 name: str
 population: int
 geometry: Geometry = Field(
 sa_column=Column(Geometry(geometry_type="POLYGON", srid=3035))
 )


select(
 Country.name,
 Country.population,
 cast(Country.geometry, Geometry).ST_XMin(),
 cast(Country.geometry, Geometry).ST_YMin(),
 cast(Country.geometry, Geometry).ST_XMax(),
 cast(Country.geometry, Geometry).ST_YMax(),
 Country.geometry.ST_AsSVG(),
)

Description

I'm selecting multiple model attributes and calculated attributes and there is a mypy error:

No overload variant of "select" matches argument types "Any", "Any", "Any", "Any", "Any", "Any", "Any"

A long list of "Possible overload variants" follows.

PS.: There is no error when I from sqlalchemy import select. The mypy error only happens if I from sqlmodel import select. In the former case, however, sqlmodel.Session complains if I use it with sqlalchemy.select.

Operating System

Linux

Operating System Details

Docker image python:3.10.2-bullseye

SQLModel Version

0.0.6

Python Version

3.10

Additional Context

error: No overload variant of "select" matches argument types "str", "int", "Any", "Any", "Any", "Any", "Any"
note: Possible overload variants:
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: _TScalar_0, **kw: Any) -> SelectOfScalar[_TScalar_0]
note: def [_TModel_0 <: SQLModel] select(entity_0: Type[_TModel_0], **kw: Any) -> SelectOfScalar[_TModel_0]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: _TScalar_0, entity_1: _TScalar_1, **kw: Any) -> Select[Tuple[_TScalar_0, _TScalar_1]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_1 <: SQLModel] select(entity_0: _TScalar_0, entity_1: Type[_TModel_1], **kw: Any) -> Select[Tuple[_TScalar_0, _TModel_1]]
note: def [_TModel_0 <: SQLModel, _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: Type[_TModel_0], entity_1: _TScalar_1, **kw: Any) -> Select[Tuple[_TModel_0, _TScalar_1]]
note: def [_TModel_0 <: SQLModel, _TModel_1 <: SQLModel] select(entity_0: Type[_TModel_0], entity_1: Type[_TModel_1], **kw: Any) -> Select[Tuple[_TModel_0, _TModel_1]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: _TScalar_0, entity_1: _TScalar_1, entity_2: _TScalar_2, **kw: Any) -> Select[Tuple[_TScalar_0, _TScalar_1, _TScalar_2]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_2 <: SQLModel] select(entity_0: _TScalar_0, entity_1: _TScalar_1, entity_2: Type[_TModel_2], **kw: Any) -> Select[Tuple[_TScalar_0, _TScalar_1, _TModel_2]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_1 <: SQLModel, _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: _TScalar_0, entity_1: Type[_TModel_1], entity_2: _TScalar_2, **kw: Any) -> Select[Tuple[_TScalar_0, _TModel_1, _TScalar_2]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_1 <: SQLModel, _TModel_2 <: SQLModel] select(entity_0: _TScalar_0, entity_1: Type[_TModel_1], entity_2: Type[_TModel_2], **kw: Any) -> Select[Tuple[_TScalar_0, _TModel_1, _TModel_2]]
note: def [_TModel_0 <: SQLModel, _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: Type[_TModel_0], entity_1: _TScalar_1, entity_2: _TScalar_2, **kw: Any) -> Select[Tuple[_TModel_0, _TScalar_1, _TScalar_2]]
note: def [_TModel_0 <: SQLModel, _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_2 <: SQLModel] select(entity_0: Type[_TModel_0], entity_1: _TScalar_1, entity_2: Type[_TModel_2], **kw: Any) -> Select[Tuple[_TModel_0, _TScalar_1, _TModel_2]]
note: def [_TModel_0 <: SQLModel, _TModel_1 <: SQLModel, _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: Type[_TModel_0], entity_1: Type[_TModel_1], entity_2: _TScalar_2, **kw: Any) -> Select[Tuple[_TModel_0, _TModel_1, _TScalar_2]]
note: def [_TModel_0 <: SQLModel, _TModel_1 <: SQLModel, _TModel_2 <: SQLModel] select(entity_0: Type[_TModel_0], entity_1: Type[_TModel_1], entity_2: Type[_TModel_2], **kw: Any) -> Select[Tuple[_TModel_0, _TModel_1, _TModel_2]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_3 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: _TScalar_0, entity_1: _TScalar_1, entity_2: _TScalar_2, entity_3: _TScalar_3, **kw: Any) -> Select[Tuple[_TScalar_0, _TScalar_1, _TScalar_2, _TScalar_3]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_3 <: SQLModel] select(entity_0: _TScalar_0, entity_1: _TScalar_1, entity_2: _TScalar_2, entity_3: Type[_TModel_3], **kw: Any) -> Select[Tuple[_TScalar_0, _TScalar_1, _TScalar_2, _TModel_3]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_2 <: SQLModel, _TScalar_3 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: _TScalar_0, entity_1: _TScalar_1, entity_2: Type[_TModel_2], entity_3: _TScalar_3, **kw: Any) -> Select[Tuple[_TScalar_0, _TScalar_1, _TModel_2, _TScalar_3]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_2 <: SQLModel, _TModel_3 <: SQLModel] select(entity_0: _TScalar_0, entity_1: _TScalar_1, entity_2: Type[_TModel_2], entity_3: Type[_TModel_3], **kw: Any) -> Select[Tuple[_TScalar_0, _TScalar_1, _TModel_2, _TModel_3]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_1 <: SQLModel, _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_3 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: _TScalar_0, entity_1: Type[_TModel_1], entity_2: _TScalar_2, entity_3: _TScalar_3, **kw: Any) -> Select[Tuple[_TScalar_0, _TModel_1, _TScalar_2, _TScalar_3]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_1 <: SQLModel, _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_3 <: SQLModel] select(entity_0: _TScalar_0, entity_1: Type[_TModel_1], entity_2: _TScalar_2, entity_3: Type[_TModel_3], **kw: Any) -> Select[Tuple[_TScalar_0, _TModel_1, _TScalar_2, _TModel_3]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_1 <: SQLModel, _TModel_2 <: SQLModel, _TScalar_3 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: _TScalar_0, entity_1: Type[_TModel_1], entity_2: Type[_TModel_2], entity_3: _TScalar_3, **kw: Any) -> Select[Tuple[_TScalar_0, _TModel_1, _TModel_2, _TScalar_3]]
note: def [_TScalar_0 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_1 <: SQLModel, _TModel_2 <: SQLModel, _TModel_3 <: SQLModel] select(entity_0: _TScalar_0, entity_1: Type[_TModel_1], entity_2: Type[_TModel_2], entity_3: Type[_TModel_3], **kw: Any) -> Select[Tuple[_TScalar_0, _TModel_1, _TModel_2, _TModel_3]]
note: def [_TModel_0 <: SQLModel, _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_3 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: Type[_TModel_0], entity_1: _TScalar_1, entity_2: _TScalar_2, entity_3: _TScalar_3, **kw: Any) -> Select[Tuple[_TModel_0, _TScalar_1, _TScalar_2, _TScalar_3]]
note: def [_TModel_0 <: SQLModel, _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_3 <: SQLModel] select(entity_0: Type[_TModel_0], entity_1: _TScalar_1, entity_2: _TScalar_2, entity_3: Type[_TModel_3], **kw: Any) -> Select[Tuple[_TModel_0, _TScalar_1, _TScalar_2, _TModel_3]]
note: def [_TModel_0 <: SQLModel, _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_2 <: SQLModel, _TScalar_3 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: Type[_TModel_0], entity_1: _TScalar_1, entity_2: Type[_TModel_2], entity_3: _TScalar_3, **kw: Any) -> Select[Tuple[_TModel_0, _TScalar_1, _TModel_2, _TScalar_3]]
note: def [_TModel_0 <: SQLModel, _TScalar_1 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_2 <: SQLModel, _TModel_3 <: SQLModel] select(entity_0: Type[_TModel_0], entity_1: _TScalar_1, entity_2: Type[_TModel_2], entity_3: Type[_TModel_3], **kw: Any) -> Select[Tuple[_TModel_0, _TScalar_1, _TModel_2, _TModel_3]]
note: def [_TModel_0 <: SQLModel, _TModel_1 <: SQLModel, _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TScalar_3 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: Type[_TModel_0], entity_1: Type[_TModel_1], entity_2: _TScalar_2, entity_3: _TScalar_3, **kw: Any) -> Select[Tuple[_TModel_0, _TModel_1, _TScalar_2, _TScalar_3]]
note: def [_TModel_0 <: SQLModel, _TModel_1 <: SQLModel, _TScalar_2 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None), _TModel_3 <: SQLModel] select(entity_0: Type[_TModel_0], entity_1: Type[_TModel_1], entity_2: _TScalar_2, entity_3: Type[_TModel_3], **kw: Any) -> Select[Tuple[_TModel_0, _TModel_1, _TScalar_2, _TModel_3]]
note: def [_TModel_0 <: SQLModel, _TModel_1 <: SQLModel, _TModel_2 <: SQLModel, _TScalar_3 in (Column[Any], Sequence[Any], Mapping[Any, Any], UUID, datetime, float, int, bool, bytes, str, None)] select(entity_0: Type[_TModel_0], entity_1: Type[_TModel_1], entity_2: Type[_TModel_2], entity_3: _TScalar_3, **kw: Any) -> Select[Tuple[_TModel_0, _TModel_1, _TModel_2, _TScalar_3]]
note: def [_TModel_0 <: SQLModel, _TModel_1 <: SQLModel, _TModel_2 <: SQLModel, _TModel_3 <: SQLModel] select(entity_0: Type[_TModel_0], entity_1: Type[_TModel_1], entity_2: Type[_TModel_2], entity_3: Type[_TModel_3], **kw: Any) -> Select[Tuple[_TModel_0, _TModel_1, _TModel_2, _TModel_3]]
Found 1 error in 1 file (checked 6 source files)

[anentropic]

I have similar errors:

repository.py:124: error: No overload variant of "select" matches argument types "Optional[bool]", "Function[NullType]" [call-overload]
repository.py:147: error: No overload variant of "exec" of "Session" matches argument type "Function[NullType]" [call-overload]
repository.py:151: error: No overload variant of "exec" of "Session" matches argument type "Function[NullType]" [call-overload]

line 124:

select(GameSession.user_won, func.count())

line 147:

session.exec(func.avg(avg_query.subquery().c.count))

line 151:

session.exec(
 func.avg(
 avg_query.filter(GameSession.user_won == True)
 .subquery()
 .c.count
 )
)

[phaabe]

You guys are not alone. Only solution at the moment: import select from sqlalchemy. But this only solves this, because sqlalchemy has no type annotations.

Any other solution found yet? Or is the way of doing things here not the way it should be?

[imankulov]

To anyone who comes across this issue as I did, the solution apparently is to wrap column expressions with the col() wrapper as documented here: https://sqlmodel.tiangolo.com/tutorial/where/#type-annotations-and-errors.

For example:

from sqlmodel import col
...
select(col(GameSession.user_won), func.count())

[brechin]

I'm running into this issue as well. For me, and the OP, this appears to be caused by having "too many" arguments, where "too many" is > 4 since the select overload variants max out at 4 arguments.

Looking at the implementation of select, I went with the following approach to get around the type checking issue:

query: Select[tuple[ModelA, int, int, int, int]] = (
 Select(
 Model,
 col(subquery.c.a), # These subquery columns are all from `func.count`
 col(subquery.c.b),
 col(subquery.c.c),
 col(subquery.c.d),
 ).join(...)

r = session.exec(query).all()

[isbldr]

Commenting to chime in that doing what was suggested in related PR would help me with this issue.