Skip to content

No overload variant of "select" matches argument types #271

New issue
New issue
Open
#1333
Open
No overload variant of "select" matches argument types#271
#1333
Labels
questionFurther information is requested
@StefanBrand

Description

@StefanBrand
StefanBrand
opened on Mar 15, 2022 · edited by 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)

Activity

StefanBrand
added
questionFurther information is requested
on Mar 15, 2022
StefanBrand
mentioned this on Mar 15, 2022
anentropic

anentropic commented on May 18, 2023

@anentropic
anentropic
on May 18, 2023

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

phaabe commented on Oct 13, 2023

@phaabe
phaabe
on Oct 13, 2023 · edited by 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

imankulov commented on Dec 27, 2023

@imankulov
imankulov
on Dec 27, 2023

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

brechin commented on Sep 5, 2024

@brechin
brechin
on Sep 5, 2024

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()
GiorgioPorgio
mentioned this on Mar 19, 2025
GiorgioPorgio
linked a pull request that will close this issue on Mar 27, 2025
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    questionFurther information is requested

    Type

    No type

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

      Development

      Participants

      @imankulov@brechin@anentropic@StefanBrand@phaabe

      Issue actions
        No overload variant of "select" matches argument types · Issue #271 · fastapi/sqlmodel