### Describe the use case ### AsyncAdapt_oracledb_cursor._aenter_cursor uses sync __enter__() instead of async __aenter__() **Where:** https://github.com/sqlalchemy/sqlalchemy/blob/c8e26d5c9ffcde0a82b4b7fa5de27f0c6bc46bec/lib/sqlalchemy/dialects/oracle/oracledb.py#L754-L758 Compare to the base class it overrides, wh...

### Describe the bug `get_unique_constraints` on the SQLite dialect scans the stored `CREATE TABLE` text (taken verbatim from `sqlite_master.sql`) with an inline-`UNIQUE` regex whose tail is `[\t ]+[a-z0-9_ ]+?[\t ]+UNIQUE`. The lazy middle class itself contains a space, so all three quantifiers can lay claim to the...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/13378 <div type='discussions-op-text'> ^{Originally posted by **ollz272** June 16, 2026} Add `orm/_loading_cy.py` with `_InstancesBatch`, a whole-chunk row processor built by `_instance_processor()` for the non-refresh, non-polymorphic loa...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/13375 <div type='discussions-op-text'> ^{Originally posted by **ollz272** June 16, 2026} `_SubqCollections._load` iterated the `Query`, which routes through `Query.__iter__ -> result.unique()` and builds a `Row` object (plus runs the uniqu...

### Ensure stubs packages are not installed - [x] No sqlalchemy stub packages is installed (both `sqlalchemy-stubs` and `sqlalchemy2-stubs` are not compatible with v2) ### Verify if the api is typed - [x] The api is not in a module listed in [#6810](https://github.com/sqlalchemy/sqlalchemy/issues/6810) so it should...

### Describe the use case This could be used for example to speed-up the check done by the `create_all` metadata something similar to the multi-reflection api, the method could be called `has_multi_table` discussed in #13295 ### Databases / Backends / Drivers targeted any ### Example Use ```py inspect(conn).has_muti...

## Summary SQLAlchemy now targets Python >= 3.10, so legacy `typing.Union` and `typing.Optional` annotations can be modernized to PEP 604 union syntax. Examples: - `Optional[T]` -> `T | None` - `Union[A, B]` -> `A | B` - `typing.Optional[T]` -> `T | None` - `typing.Union[A, B]` -> `A | B` ## Scope Audit and update P...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/13249 trying to do this, cannot get any typing combination to be accepted by pyright much less mypy: ```py from typing import overload from sqlalchemy import func, Integer, column from sqlalchemy import select from sqlalchemy.ext.hybrid import hyb...

### Describe the bug The new `default_factory` validation introduced in commit [95ad9fe](https://github.com/sqlalchemy/sqlalchemy/commit/95ad9fe42b888d7cdea60b7a71c833cbb8667887) (related to #12168) breaks `WriteOnlyMapped` relationships that use `default_factory=list` in Declarative Dataclass Mapping. ### Optional...

### Describe the use case Sql server 2025 seems to have added native json support https://learn.microsoft.com/en-us/sql/t-sql/data-types/json-data-type?view=sql-server-ver17 I guess we should decide what to do with the existing JSON type: https://docs.sqlalchemy.org/en/20/dialects/mssql.html#sqlalchemy.dialects.mssq...

> Asked claude to fuzz this and it did find a similar case, let me know if you prefer me to open another issue or if we should re-open this one. Seem very similar: it accesses the parent relationship via `poly.Cls.parent_rel` that's similar to what was fixed here `poly.Cls.cls_rel` > > while strange I think it shoul...

There are a couple of cases where immediateload fails when using inheritance on relationships: - loading using immediateload a relationship on an inheritance chain that's being loaded via eager loading: `select(Meta).option(anyloader(Meta.parent_cls).immediateload(ParentCls.relationship))` - loading using immediatel...

In `lib/sqlalchemy/pool/base.py`, `_ConnectionRecord.get_connection` detects soft invalidation via: ```python # base.py, line 852 elif self._soft_invalidate_time > self.starttime: do_connect = True ``` `_soft_invalidate_time` is set with `time.time()` (line 812) and `starttime` is also set with `time.time()` (line 8...

### Describe the bug Check constraint reflection strips brackets from some expressions such that they are syntactically invalid ### Optional link from https://docs.sqlalchemy.org which documents the behavior that is expected _No response_ ### SQLAlchemy Version in Use 2.0.48 ### DBAPI (i.e. the database driver) psyc...

### Describe the use case Currently, nested composites or custom classes require implementing `__composite_values__`, which is not always an option. Internally there is `_generated_composite_accessor` which is generated if no such method provided. I suggest adding `values_getter` as an argument to `composite()` so i...

### Describe the use case Apparently sqlite supports multiple on-conflict clauses in inserts: https://sqlite.org/lang_upsert.html > If the insert operation would cause the conflict target uniqueness constraint to fail, then the insert is omitted and the corresponding DO NOTHING or DO UPDATE operation is performed in...

### Describe the use case Currently `avg` and `abs` do not have an implementation in the functions module Since these are fairly common i thing we could provide an implementation so that the correct type can be inferred. - avg is numeric (or Double) - abs instead derives its type from the input ### Databases / Backe...

### Describe the use case Add a flag in the constraints and index to prevent them from automatically being added to the table collections. They can be added manually either by providing them to the table constructor or using the table methods to add constraints ### Databases / Backends / Drivers targeted Any ### Exa...

Follow up of #13006 Set to False the default value and remove the warning

a long term solution would be to pull the asyncio extension out of the .ext/ namespace so that the imports would be `from sqlalchemy.asyncio import create_async_engine` and `from sqlalchemy.orm.asycnio import AsyncSession`. Then `sqlalchemy.ext.asyncio` would be a compatibility shim that isn't needed, the same way D...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/12797 <div type='discussions-op-text'> ^{Originally posted by **OscarRomaFever** August 12, 2025} Hi! I would like to know if it is possible to manage a Two-Phase Commit (2PC) transaction using asynchronous connections with PostgreSQL in S...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/12709 Locally I can only reproduce this using a trusted connection against a PG database running in a local container, which I can run like this: podman run -d --rm -e POSTGRES_HOST_AUTH_METHOD=trust -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=...

### Describe the use case Traditional strategies ('select', 'raise', 'subquery') for accessing a lazy-loaded relationship relationship don't work in an async context, as the database call loading the related instance yields to the event loop before a necessarily synchronous attribute access would otherwise return. T...

### Describe the use case MariaDB has introduced a new Vector data type in version 11.7. Details can be found here: https://mariadb.org/projects/mariadb-vector/ The main issue I'm running into now is that reflection fails when reflecting on any table that has a vector column. The reflection fails to retrieve the col...

### Describe the use case see https://docs.python.org/3/library/sqlite3.html#sqlite3.Connection.autocommit for the new feature (which was many years in the making) from discussion at https://github.com/sqlalchemy/alembic/issues/1655 : 1. SQLAlchemy's documentation needs to be updated to reflect that the "correct tra...

### Describe the use case ```python @dataclasses.dataclass class Person: first_name: int last_name: str # ... class Housing(Base): person: composite(Person, column_prefix='person') ``` would result in mapped column names `person_first_name` and `person_last_name` right now, the API is a bit verbose and hard to read:...

This has likely been broken since v2 https://github.com/sqlalchemy/sqlalchemy/blob/a84444fca1c436179ad847ce99e8a013a84b5b33/lib/sqlalchemy/dialects/mysql/base.py#L2772-L2774 Apparently there is no test that covers this

### Describe the use case I just received the following error of in my project and have an improvement request similar to #10668 : ``` sqlalchemy.exc.InvalidRequestError: Loader strategies for ORM Path[Mapper[Cable(cable)] -> Cable.cablesides -> Mapper[CadCableSide(cad_cable_side)]] conflict ``` While this tells me...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/12337 support for FETCH EXACT/APPROXIMATE feature described at https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/SELECT.html#GUID-CFA006CA-6FF1-4972-821E-6996142A51C6__BABBADDD

## update Currently `eager_default=True` in case of an update of multiple rows does the following: - when the driver supports returning, runs single updates with returning, one for each row. Results in n queries - when the driver does not support returning, runs execute many updates and one select for each rows. Res...

### Describe the use case The [Postgres docs](https://www.postgresql.org/docs/17/sql-select.html) specifically say that you should be able to have both a FOR UPDATE and a FOR SHARE in the same query: > Multiple locking clauses can be written if it is necessary to specify different locking behavior for different tabl...

### Describe the bug I can't use an enum type as part of a `case()` without casting. Looks very similar to https://github.com/sqlalchemy/sqlalchemy/issues/6515 ### Optional link from https://docs.sqlalchemy.org which documents the behavior that is expected _No response_ ### SQLAlchemy Version in Use 2.0.36 ### DBAPI...

### Describe the bug I have a statement like the following, which works on SQLAlchemy 1.4 but not on 2.0 ```python delete(Author).where(Author.id == Book.author_id).returning(Book.title) ``` ### Optional link from https://docs.sqlalchemy.org which documents the behavior that is expected https://docs.sqlalchemy.org/e...

### Ensure stubs packages are not installed - [X] No sqlalchemy stub packages is installed (both `sqlalchemy-stubs` and `sqlalchemy2-stubs` are not compatible with v2) ### Verify if the api is typed - [X] The api is not in a module listed in [#6810](https://github.com/sqlalchemy/sqlalchemy/issues/6810) so it should...

### Describe the bug The `get_check_constraints` method of SQLiteDialect, does not correctly handle multi line CHECK constraints in SQLAlchemy reflection. When performing a alembic batch_op for example, multi line check constraints will not be or wrongly reflected and can result in SQL errors. ### Optional link from...

### Describe the bug Given a model `A` with a column_property `B`, a query that loads an `aliased` of `A` will emit the `B` expression multiple times (exact number depends on the complexity of the query). ### Optional link from https://docs.sqlalchemy.org which documents the behavior that is expected _No response_ #...

Discussed in #11613 Add a boolean flag in the mssql dialect, the default will be set to `warn` meaning that a warning will be raised when `_enable_identity_insert` is detected set to true. User can opt into the current behaviour or disable it

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/11548 The generic type for `Enum` needs to be a typevar for pyright: ```py from __future__ import annotations import enum from sqlalchemy import Enum from sqlalchemy import func from sqlalchemy.orm import column_property from sqlalchemy.orm import...

### Describe the bug When using PEP563 postponed annotations (i.e. `from __future__ import annotations`), mapped classes with the same name in different modules cannot be used in relationships using type annotations alone. For example, if `mod1` and `mod2` both contain mapped classes called `Model`, then `attr: Mapp...

The reflected column dict https://docs.sqlalchemy.org/en/20/core/reflection.html#sqlalchemy.engine.interfaces.ReflectedColumn includes only the already reflected type instance from the dialect. This means that for unknown sql types, the sqlalchemy nulltype is provided, losing any information about what was reflected...

### Describe the bug I get a table not found error when trying to reflect a synonym of a synonym on a dblink. I try reflecting the table as such ``` self._engine = sql.create_engine(uri, echo='debug') sql.Table(table_name, self._metadata, schema=self._schema, autoload_with=self._engine, oracle_resolve_synonyms=True)...

### Discussed in https://github.com/sqlalchemy/alembic/discussions/1458 the [conv](https://docs.sqlalchemy.org/en/20/core/constraints.html#sqlalchemy.schema.conv) construct applies truncation rules to identifiers, and users are using it this way. We can't change that, so document it and ensure unit tests are present...

### Describe the use case When a polymorphic table is created via joined table inheritance, I would expect that deleting a row in the subclass table would also delete the row in the parent table. I've found that when the subclass row is explicitly deleted, the delete propgates to the parent table as I would expect....

### Describe the bug Hi im trying to get startet with sql alchemy and alembic and just found a bug. during the translation of a double precision=17, and decimal_return_scale=7 into mysql i always get an exception. `sqlalchemy.exc.ArgumentError: You must specify both precision and scale or omit both altogether.` When...

### Describe the use case In postgresql documentation (https://www.postgresql.org/docs/current/sql-createtable.html) create table have the "with" option that is not supported by sqlalchemy currently. The change is simple: https://github.com/sqlalchemy/sqlalchemy/commit/45b70d4e7c0ac31005f8a93253fe477dfc27afb4 ### Da...

### Describe the bug Hey, the following code raises an `NameError: Could not de-stringify annotation 'long str'`. But as soon as I changed `Annotated[str, "long str"]` to `Annotated[str, "long_str"]` it works. Any idea about what's going on here? fin swimmer ### Optional link from https://docs.sqlalchemy.org which d...

### Describe the bug ## Description The following code yields a strange result. I'm expecting `bar_1`, `bar_2`, and `bar_3` to be mapped as `CompositeBar(value_1="a", value_2="b")`, `CompositeBar(value_1="c", value_2="d")`, and `CompositeBar(value_1="e", value_2="f")` respectively, but actually it ended up with ever...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/10934 looks like this was never tested. might not have an immediate solution ```py def test_no_double_update_on_delete_bidirectional_post_update(self): person, ball, Ball, Person = ( self.tables.person, self.tables.ball, self.classes.Ball, self.cl...

### Describe the bug There are a number of issues with the sqlalchemy.ext.orderinglist:OrderingList type hints and implementation: 1. The ordering function is documented as being allowed to return any type of object, and the tests demonstrate this by returning strings. The type annotation requires it to return integ...

this can come in alongside #4641 this would make a change to `relationship` such that it does not set up `strategy_key` until mapper config stage, where it gets a look at its parent mapper. should be mentioned in docs particularly here: https://github.com/sqlalchemy/sqlalchemy/blob/d9ed5cb521d5e7a2b62646b43eaebc1ccf...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/10833 This apparently was possible in 1.4 but not in 2.0 when cython extensions are built: ```py # sqlalchemy 2.0.25 from sqlalchemy import ForeignKey from sqlalchemy import inspect from sqlalchemy.orm import DeclarativeBase from sqlalchemy.orm im...

### Describe the use case aliased() currently prohibits a name in conjunction with `flat=True`. Presumably this is because it would require some arbitrary naming convention. In reality, `flat=True` already has an arbitrary naming convention (suffix with numbers) which is useful for the query compiler, but not so muc...

### Describe the bug There's a nasty interaction between the following: * some import-time caching in SQLAlchemy (in [`sqlalchemy.inspection._registrars`](https://github.com/sqlalchemy/sqlalchemy/blob/66be1482db06adb908432b2e3b41d9393d1319f7/lib/sqlalchemy/inspection.py#L53)), * the way Coverage.py handles editable...

### Describe the bug If I create a temporary table (name starting with a `#`) using MSSQL, then inspect the table metadata, it has a constraint `{PrimaryKeyConstraint()}`. However, none of the columns are detected as primary keys and the primary key constraint has no name. The names of the primary key constraints ar...

The current default drivers selection for some database is outdated or not really useful anymore. An idea for 2.1 is to start raising a deprecation warning when a default drivers is selected. Optionally the default behaviour is something that can be kept were it makes sense. In particular oracle and sqlite seem the...

Will compile a table with min version. Let's target at least 2 years for dialect packages and something sensible for the databases Databases |db | best_effort | normal |full| notes | |---|-------------|--------|----|-------| |mssql|2005 -> 2008| - | -|remove warning on _setup_version_attributes| |mysql|5.0.2->5.1|-|...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/10514 <div type='discussions-op-text'> ^{Originally posted by **anentropic** October 20, 2023} I am trying to bulk update via an insert on duplicate, but using `from_select` (instead of list of values as seen here https://github.com/sqlalc...

Since version 1.4 that added support for relationship refresh, the implementation is sub-optimal, since it will always perform a query to the model table, followed by a query to the related table. ```py from __future__ import annotations from sqlalchemy import create_engine from sqlalchemy import ForeignKey from sql...

### Describe the bug using windows and pysqlcipher in python 3.11 get error to create engine with very basic usage ### Optional link from https://docs.sqlalchemy.org which documents the behavior that is expected _No response_ ### SQLAlchemy Version in Use 2.0.22 ### DBAPI (i.e. the database driver) pysqlcipher ### D...

The current code when executing something like `conn.execute(...).scalars().all()` will create a Row object, at least in some cases, that is then discarded. The code should try to avoid doing the unnecessary row creation

### Describe the bug Hi :wave: First of all thank you for the huge amount of work done on SQLAlchemy, I really enjoy using this library :rocket: I'm trying to implement a many-to-many relationship (like explained [here](https://docs.sqlalchemy.org/en/20/orm/basic_relationships.html#setting-bi-directional-many-to-man...

### Ensure stubs packages are not installed - [X] No sqlalchemy stub packages is installed (both `sqlalchemy-stubs` and `sqlalchemy2-stubs` are not compatible with v2) ### Verify if the api is typed - [X] The api is not in a module listed in [#6810](https://github.com/sqlalchemy/sqlalchemy/issues/6810) so it should...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/10439 <div type='discussions-op-text'> ^{Originally posted by **flyly0755** October 9, 2023} There is such a situation, data of different sources need to insert to one table, but the data column is a little different, for example: Data fro...

### Describe the bug When trying to fetch all the tables from a MSSQL database (clean database via Docker https://hub.docker.com/_/microsoft-mssql-server) with the MetaData().reflect(bind=engine) it raises a NoSuchTableError on a temporary table (starting with a #) that indeed does not exist. This worked on SQLAlche...

### Describe the bug I found a typing oddity with 2.0 that is not in the guide. Legacy code utilizing a `Session().query().subquery()` will run fine (and emit warnings that is it making a coercion) - but does not pass mypy becauce of the coercion. I'm not sure if this is a typing bug or not, as the legacy format is...

### Describe the bug I was going through the tutorial for adding composite column types where sets of columns can be associated with a single user-defined datatype (FYR https://docs.sqlalchemy.org/en/20/orm/composites.html#composite-column-types). I tweaked the example a bit to make the composite column types option...

### Ensure stubs packages are not installed - [X] No sqlalchemy stub packages is installed (both `sqlalchemy-stubs` and `sqlalchemy2-stubs` are not compatible with v2) ### Verify if the api is typed - [X] The api is not in a module listed in [#6810](https://github.com/sqlalchemy/sqlalchemy/issues/6810) so it should...

Using them is poorly tested and the use case seems quite limited.

In some cases generics are consired invariant since the mapped descriptors are not declared as final. While this use case for this is likely very small, it should not be too hard to support the following form: ```py from sqlalchemy import ForeignKey from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column,...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/10325 <div type='discussions-op-text'> ^{Originally posted by **CaselIT** September 8, 2023} Currently InstrumentedAttribute is not a KeyedColumnElement so trying to use `corresponding_column` and similar raises a typing error This does no...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/10309 <div type='discussions-op-text'> ^{Originally posted by **RasulGafarov** September 4, 2023} The following code: ``` my_select = select( Values( sqlalchemy.column("column_1", String), sqlalchemy.column("column_1", String), name="temp_...

this is from https://review.opendev.org/c/openstack/oslo.db/+/888580 so far, the reproducer so far is this docker container: ``` FROM ubuntu:22.04 SHELL ["/bin/bash", "-c"] RUN apt-get update && apt-get install -y python3 tox git WORKDIR /root RUN git clone --depth 1 https://opendev.org/openstack/barbican WORKDIR /r...

- gether is messy to use with multiple sessions not created inside the task. Ref https://github.com/sqlalchemy/sqlalchemy/discussions/9312#discussioncomment-6419638

see #10027. MappedAsDataclass basically cannot support the dataclass "init" feature on a class that isn't mapped, and likely can't support *any* dataclass features on such a class as instantiated. Propose instantiation of mixins / abstract emit a warning if they are also "dataclass" produced under 2.0, error in 2.1.

### Describe the use case Currently, when I call the MetaData().reflect() function, the foreign tables are not reflected. It would be interesting to have an argument in the function to be able to search for foreign tables as well. This way facilitates DML operations on foreign tables. ### Databases / Backends / Driv...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/9928 since we retired https://docs.sqlalchemy.org/en/20/orm/constructors.html#mapping-constructors this information has been lost. also update links to that page such as https://docs.sqlalchemy.org/en/20/orm/events.html#sqlalchemy.orm.InstanceEven...

### Describe the bug We upgraded our sql alchemy version and observed a massive spike in execution time on the database. We are bulk uploading several 100k rows. We are using sql server on azure and pyodbc. We believe it relates to changes made in https://github.com/sqlalchemy/sqlalchemy/issues/9603 or https://githu...

Something that certainly **should** work, but does not, is to declare the type as a ``ClassVar[]``, since we scan these also in declarative: ```py class AlertItem2(Base): __tablename__ = "alert_items2" id = Column(BigInteger, primary_key=True, autoincrement=True) signature = Column(String) data_source_model_id = Col...

### Describe the bug If you use a `Text` type that includes a fully schema qualified collation (ie. `Text(collation="my_schema.my_collation")`), the DDL statement created when running `metadata.create_all()` is incorrect for Postgres. The statement created presently is: `TEXT COLLATE "my_schema.my_collation"` Which...

### Describe the bug What I want to do is to associate an ORM entity _USER_ with columns of FromClause produced by subquery() as described in tutorial. But when I use associated \<AliasedClass\> instance in group_by() of new _stmt_ it 'unpacks' all columns that are selected in a subquery instead of unpacking just Us...

### Ensure stubs packages are not installed - [X] No sqlalchemy stub packages is installed (both `sqlalchemy-stubs` and `sqlalchemy2-stubs` are not compatible with v2) ### Verify if the api is typed - [X] The api is not in a module listed in [#6810](https://github.com/sqlalchemy/sqlalchemy/issues/6810) so it should...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/9528 the wildcard option '*' acts recursively in some sitiuations (with no way to not be recursive) and non-recursively in others: ```py from sqlalchemy import Column from sqlalchemy import create_engine from sqlalchemy import ForeignKey from sqla...

We also seem to make inherit dataclasses attributes, while we probably should not. Not sure if it's connected to this other issue #9350 ```py from dataclasses import dataclass import sqlalchemy as sa import sqlalchemy.orm as sao import inspect class Base(sao.MappedAsDataclass, sao.DeclarativeBase, kw_only=True): pas...

### Describe the use case It would be useful to have the method [Inspector.get_unique_constraints](https://github.com/sqlalchemy/sqlalchemy/blob/rel_2_0_5/lib/sqlalchemy/engine/interfaces.py#L1562) implemented for SQL Server. My immediate use case is that alembic [uses this method](https://github.com/sqlalchemy/alem...

The following is not allowed ```py t = sa.Table( "x", sa.MetaData(), sa.Column("a", sa.Integer), sa.Column("b", sa.Integer) ) sql = """ SELECT 1 as x, 2 as y UNION ALL SELECT 3, 4 """ q = sa.select(t).union_all(sa.text(sql)) ``` but it seems to render correctly if the coerce is removed for debug

1. relationship = None issue : #9383 , #9856 - issue created: https://github.com/sqlalchemy/sqlalchemy/issues/12168 2. declared_attr on a mixin w/ dataclasses: #9408 3. order matters regarding the default value and init generated. this all comes from dataclasses, but it may be worth reiterate that 4. mention that al...

There are some examples that are not compatible with 2.0, like nested sets https://github.com/sqlalchemy/sqlalchemy/blob/8b108297d075ae68178cd18a9cb4d06feee7e075/examples/nested_sets/nested_sets.py#L56-L73 Creating a way of running the tests as part of the pipeline work help avoiding having old examples laying around

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/9368 ```py from typing import List from sqlalchemy import Column, ForeignKey from sqlalchemy.orm import relationship from sqlalchemy.types import Integer from sqlalchemy.orm import declarative_base # qualify the base with __allow_unmapped__. Can a...

### Describe the bug In SQLAlchemy, when adding new objects to relationship with default cascades and then deleting them, they are kept inside session and then inserted on flush. But when having delete-orphan cascade, the desired behavior is to remove relative object from session as it is removed from relationship c...

### Describe the use case In multiple cases it may be required to assign to a mapped class an attribute after the class definition, to for example break circular imports or similar, that is usually done by assigning the attribute to the class `ModelCls.attribute_lazy = ...` This is currently a bit awkward to impleme...

### Describe the bug Only the first column in an expression is considered ### To Reproduce ```python import sqlalchemy as sa def go(idx): sa.Table( "x", sa.MetaData(), sa.Column("x", sa.Integer), sa.Column("y", sa.Integer), idx, ) print([str(c) for c in idx.columns]) go(sa.Index("x", sa.func.div(sa.column("x"), sa.c...

### Describe the typing issue Next issue, it seems I get an error when using a `Mapped` class attribute in `Index`. ### To Reproduce Stripped down version of what I'm running: ```python @sa.orm.declarative_mixin class _Rhyme: __tablename__: str ph1: Mapped[int] ph2: Mapped[Optional[int]] @sa.orm.declared_attr def __...

### Describe the typing issue I'm going through a small project with strict type checking, so will probably end up opening a few nitpick issues. It still seems difficult to me at the moment, to figure out what types should be used for certain annotations. Maybe a new page in the docs could be added to list these typ...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/9192 Using frozen dataclasses may be useful in some cases, but implementing it will be non trivial. See mike [reply in the discussion](https://github.com/sqlalchemy/sqlalchemy/discussions/9192#discussioncomment-4820606)

### Describe the bug When running the test suite (as of 6779fa861d11668f67d780d77e4ae76965cee6f7) under PyPy3.9 7.3.11, I get the following test failures: ``` FAILED test/ext/test_associationproxy.py::DictOfTupleUpdateTest::test_update_multi_elem_varg - AssertionError: 'update expected at most 1 arguments?, got 2' !...

the event hook here: https://github.com/sqlalchemy/sqlalchemy/blob/689ebc30dcd6b9cedf01d729f748b31826720b5c/lib/sqlalchemy/orm/decl_base.py#L567-L582 that's making a global event against Mapper. Declarative should make at most just *one* event hook against Mapper, then use its own collections to locate classes for w...

### Discussed in https://github.com/sqlalchemy/sqlalchemy/discussions/9080 simple case can be reproduced on sqlite w/ new returning support ```py from sqlalchemy import Column from sqlalchemy import create_engine from sqlalchemy import DateTime from sqlalchemy import func from sqlalchemy import String from sqlalchem...

### Describe the use case I'm working on a test branch for sqlalchemy 2.0 in a codebase which uses `mypy --strict`. This means that custom subclasses of generic types must provide type parameters (`--disallow-any-generics`). But it isn't clear what the type parameters are or mean in the 2.0 documentation branch. ###...

discovered during #8989, this is simply not implemented at all and the bind expression is ignored when it's an element of a tuple. Also, the impl of a TupleType() is not getting the internal types propagated along, which is part of what would be needed for this to work ```py from sqlalchemy import Column from sqlalc...

### Describe the use case The SA Range does not have an exact notion of its "type", i.e. there is no way to determine the data type of an empty or infinite range. ### Databases / Backends / Drivers targeted The `Range` class is specific to PostgreSQL, but is driver-agnostic. ### Example Use For example, my app shows...