-
Notifications
You must be signed in to change notification settings - Fork 41
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Static typing using Cast expects two type arguments #115
Comments
@MaicoTimmerman, bump 😛 |
SQLAlchemy's Cast accepts a TypeEngine object, not a Python type. So here the more correct thing would be cast[sqlalchemy.types.Numeric]. We don't express SQL constructs in terms of Python datatypes, there is a layer of indirection from the TypeEngine. |
But this still would be one type argument, not two; isn't that right? |
from my POV it seems like you care about the resulting type of the construct, not the originating type, so yes. but i may not be seeing the whole picture. |
Yeah, that makes sense that I've approached from the different direction. But nevertheless the issue still stands as present. Unless I need to provide both originating & resulting types. I'll check tomorrow. |
I've looked into the originating+resulting vs resulting only generic type. I believe to be fully typed, we need both. However we'd need to do some more thinking about the source type to be ORM compatible. Currently, it expects a source to be inherited from from sqlalchemy import cast, Float, Column, Numeric
from sqlalchemy.orm import declarative_base
Base = declarative_base()
class X(Base):
y = Column(Float)
x = X()
x.y = 2.0
reveal_type(x.y)
reveal_type(cast(x.y, Numeric)) # error: Value of type variable "_CLE" of "Cast" cannot be "float"
reveal_type(cast(X.y, Numeric)) # works I also noted that the generic is currently |
Well the ".clause" of the Cast is really not important on the outside, it's there for informational purposes but does not determine any meaningful behavior of the construct, only the specifics of the string that is generated in compilation. There has to be some kind of boundary for what we put in the
I don't think every member of an object that happens to have a SQL type needs to be part of the generic representation, and perhaps we should try to clarify what really goes into the |
based on this issue I had some code like: rows = await session.execute(
sql.select([func.pg_try_advisory_xact_lock(cast(key, BigInteger))])
) where this worked fine in my unit tests, but mypy complains:
After a bit of experimenting I found this formulation that works and also satisfies mypy: rows = await session.execute(
sql.select([func.pg_try_advisory_xact_lock(literal(key, BigInteger))])
) |
|
I think that's mypy |
Oh my bad! Totally read it as typing cast |
Describe the bug
We have a statically typed dictionary that has values of type
Cast[Decimal]
& it seems to be valid, since we cast column value toFLOAT
. But the type annotation expects two type arguments. I think it uses this stub: https://github.com/sqlalchemy/sqlalchemy2-stubs/blob/master/sqlalchemy-stubs/sql/elements.pyi#L333whereas it's for a method
cast
onColumnElement
.Expected behavior
Static typing using
Cast[Decimal]
works fine :PTo Reproduce
Error
Versions.
Additional context
Maybe we should actually not use
cast
in this case? We are using it becausey
is anOptional[float]
& notfloat
, but we are 100% sure that it's notNone
?Have a nice day!
The text was updated successfully, but these errors were encountered: