SQLAlchemy 2.0.42__py3-none-any.whl → 2.0.43__py3-none-any.whl

sqlalchemy/__init__.py

@@ -269,7 +269,7 @@ from .types import Uuid as Uuid
 from .types import VARBINARY as VARBINARY
 from .types import VARCHAR as VARCHAR
 
-__version__ = "2.0.42"
+__version__ = "2.0.43"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/connectors/pyodbc.py

@@ -243,3 +243,8 @@ class PyODBCConnector(Connector):
         else:
             dbapi_connection.autocommit = False
             super().set_isolation_level(dbapi_connection, level)
+
+    def detect_autocommit_setting(
+        self, dbapi_conn: interfaces.DBAPIConnection
+    ) -> bool:
+        return bool(dbapi_conn.autocommit)

sqlalchemy/dialects/mysql/aiomysql.py

@@ -98,6 +98,9 @@ class AsyncAdapt_aiomysql_connection(AsyncAdapt_dbapi_connection):
     def autocommit(self, value: Any) -> None:
         self.await_(self._connection.autocommit(value))
 
+    def get_autocommit(self) -> bool:
+        return self._connection.get_autocommit()  # type: ignore
+
     def terminate(self) -> None:
         # it's not awaitable.
         self._connection.close()

sqlalchemy/dialects/mysql/asyncmy.py

@@ -104,6 +104,9 @@ class AsyncAdapt_asyncmy_connection(AsyncAdapt_dbapi_connection):
     def autocommit(self, value: Any) -> None:
         self.await_(self._connection.autocommit(value))
 
+    def get_autocommit(self) -> bool:
+        return self._connection.get_autocommit()  # type: ignore
+
     def terminate(self) -> None:
         # it's not awaitable.
         self._connection.close()

sqlalchemy/dialects/mysql/mariadbconnector.py

@@ -253,6 +253,9 @@ class MySQLDialect_mariadbconnector(MySQLDialect):
             "AUTOCOMMIT",
         )
 
+    def detect_autocommit_setting(self, dbapi_conn: DBAPIConnection) -> bool:
+        return bool(dbapi_conn.autocommit)
+
     def set_isolation_level(
         self, dbapi_connection: DBAPIConnection, level: IsolationLevel
     ) -> None:

sqlalchemy/dialects/mysql/mysqlconnector.py

@@ -277,6 +277,9 @@ class MySQLDialect_mysqlconnector(MySQLDialect):
             "AUTOCOMMIT",
         )
 
+    def detect_autocommit_setting(self, dbapi_conn: DBAPIConnection) -> bool:
+        return bool(dbapi_conn.autocommit)
+
     def set_isolation_level(
         self, dbapi_connection: DBAPIConnection, level: IsolationLevel
     ) -> None:

sqlalchemy/dialects/mysql/mysqldb.py

@@ -298,6 +298,9 @@ class MySQLDialect_mysqldb(MySQLDialect):
             "AUTOCOMMIT",
         )
 
+    def detect_autocommit_setting(self, dbapi_conn: DBAPIConnection) -> bool:
+        return dbapi_conn.get_autocommit()  # type: ignore[no-any-return]
+
     def set_isolation_level(
         self, dbapi_connection: DBAPIConnection, level: IsolationLevel
     ) -> None:

sqlalchemy/dialects/oracle/__init__.py

@@ -35,8 +35,10 @@ from .base import VARCHAR2
 from .base import VECTOR
 from .base import VectorIndexConfig
 from .base import VectorIndexType
+from .vector import SparseVector
 from .vector import VectorDistanceType
 from .vector import VectorStorageFormat
+from .vector import VectorStorageType
 
 # Alias oracledb also as oracledb_async
 oracledb_async = type(
@@ -74,4 +76,6 @@ __all__ = (
     "VectorIndexType",
     "VectorIndexConfig",
     "VectorStorageFormat",
+    "VectorStorageType",
+    "SparseVector",
 )

sqlalchemy/dialects/oracle/base.py

@@ -729,8 +729,22 @@ VECTOR Datatype
 
 Oracle Database 23ai introduced a new VECTOR datatype for artificial intelligence
 and machine learning search operations. The VECTOR datatype is a homogeneous array
-of 8-bit signed integers, 8-bit unsigned integers (binary), 32-bit floating-point numbers,
-or 64-bit floating-point numbers.
+of 8-bit signed integers, 8-bit unsigned integers (binary), 32-bit floating-point
+numbers, or 64-bit floating-point numbers.
+
+A vector's storage type can be either DENSE or SPARSE. A dense vector contains
+meaningful values in most or all of its dimensions. In contrast, a sparse vector
+has non-zero values in only a few dimensions, with the majority being zero.
+
+Sparse vectors are represented by the total number of vector dimensions, an array
+of indices, and an array of values where each value’s location in the vector is
+indicated by the corresponding indices array position. All other vector values are
+treated as zero.
+
+The storage formats that can be used with sparse vectors are float32, float64, and
+int8. Note that the binary storage format cannot be used with sparse vectors.
+
+Sparse vectors are supported when you are using Oracle Database 23.7 or later.
 
 .. seealso::
 
@@ -738,17 +752,26 @@ or 64-bit floating-point numbers.
     <https://python-oracledb.readthedocs.io/en/latest/user_guide/vector_data_type.html>`_ - in the documentation
     for the :ref:`oracledb` driver.
 
-.. versionadded:: 2.0.41
+.. versionadded:: 2.0.41 - Added VECTOR datatype
+
+.. versionadded:: 2.0.43 - Added DENSE/SPARSE support
 
 CREATE TABLE support for VECTOR
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-With the :class:`.VECTOR` datatype, you can specify the dimension for the data
-and the storage format. Valid values for storage format are enum values from
-:class:`.VectorStorageFormat`. To create a table that includes a
-:class:`.VECTOR` column::
+With the :class:`.VECTOR` datatype, you can specify the number of dimensions,
+the storage format, and the storage type for the data. Valid values for the
+storage format are enum members of :class:`.VectorStorageFormat`. Valid values
+for the storage type are enum members of :class:`.VectorStorageType`. If
+storage type is not specified, a DENSE vector is created by default.
+
+To create a table that includes a :class:`.VECTOR` column::
 
-    from sqlalchemy.dialects.oracle import VECTOR, VectorStorageFormat
+    from sqlalchemy.dialects.oracle import (
+        VECTOR,
+        VectorStorageFormat,
+        VectorStorageType,
+    )
 
     t = Table(
         "t1",
@@ -756,7 +779,11 @@ and the storage format. Valid values for storage format are enum values from
         Column("id", Integer, primary_key=True),
         Column(
             "embedding",
-            VECTOR(dim=3, storage_format=VectorStorageFormat.FLOAT32),
+            VECTOR(
+                dim=3,
+                storage_format=VectorStorageFormat.FLOAT32,
+                storage_type=VectorStorageType.SPARSE,
+            ),
         ),
         Column(...),
         ...,
@@ -764,31 +791,40 @@ and the storage format. Valid values for storage format are enum values from
 
 Vectors can also be defined with an arbitrary number of dimensions and formats.
 This allows you to specify vectors of different dimensions with the various
-storage formats mentioned above.
+storage formats mentioned below.
 
 **Examples**
 
-* In this case, the storage format is flexible, allowing any vector type data to be inserted,
-  such as INT8 or BINARY etc::
+* In this case, the storage format is flexible, allowing any vector type data to be
+  inserted, such as INT8 or BINARY etc::
 
     vector_col: Mapped[array.array] = mapped_column(VECTOR(dim=3))
 
-* The dimension is flexible in this case, meaning that any dimension vector can be used::
+* The dimension is flexible in this case, meaning that any dimension vector can
+  be used::
 
     vector_col: Mapped[array.array] = mapped_column(
         VECTOR(storage_format=VectorStorageType.INT8)
     )
 
-* Both the dimensions and the storage format are flexible::
+* Both the dimensions and the storage format are flexible. It creates a DENSE vector::
 
     vector_col: Mapped[array.array] = mapped_column(VECTOR)
 
+* To create a SPARSE vector with both dimensions and the storage format as flexible,
+  use the :attr:`.VectorStorageType.SPARSE` storage type::
+
+    vector_col: Mapped[array.array] = mapped_column(
+        VECTOR(storage_type=VectorStorageType.SPARSE)
+    )
+
 Python Datatypes for VECTOR
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 VECTOR data can be inserted using Python list or Python ``array.array()`` objects.
-Python arrays of type FLOAT (32-bit), DOUBLE (64-bit), or INT (8-bit signed integer)
-are used as bind values when inserting VECTOR columns::
+Python arrays of type FLOAT (32-bit), DOUBLE (64-bit), INT (8-bit signed integers),
+or BINARY (8-bit unsigned integers) are used as bind values when inserting
+VECTOR columns::
 
     from sqlalchemy import insert, select
 
@@ -798,6 +834,21 @@ are used as bind values when inserting VECTOR columns::
             {"id": 1, "embedding": [1, 2, 3]},
         )
 
+Data can be inserted into a sparse vector using the :class:`_oracle.SparseVector`
+class, creating an object consisting of the number of dimensions, an array of indices, and a
+corresponding array of values::
+
+    from sqlalchemy import insert, select
+    from sqlalchemy.dialects.oracle import SparseVector
+
+    sparse_val = SparseVector(10, [1, 2], array.array("d", [23.45, 221.22]))
+
+    with engine.begin() as conn:
+        conn.execute(
+            insert(t1),
+            {"id": 1, "embedding": sparse_val},
+        )
+
 VECTOR Indexes
 ~~~~~~~~~~~~~~
 
@@ -805,6 +856,8 @@ The VECTOR feature supports an Oracle-specific parameter ``oracle_vector``
 on the :class:`.Index` construct, which allows the construction of VECTOR
 indexes.
 
+SPARSE vectors cannot be used in the creation of vector indexes.
+
 To utilize VECTOR indexing, set the ``oracle_vector`` parameter to True to use
 the default values provided by Oracle. HNSW is the default indexing method::
 
@@ -1157,14 +1210,16 @@ class OracleTypeCompiler(compiler.GenericTypeCompiler):
         return "ROWID"
 
     def visit_VECTOR(self, type_, **kw):
-        if type_.dim is None and type_.storage_format is None:
-            return "VECTOR(*,*)"
-        elif type_.storage_format is None:
-            return f"VECTOR({type_.dim},*)"
-        elif type_.dim is None:
-            return f"VECTOR(*,{type_.storage_format.value})"
-        else:
-            return f"VECTOR({type_.dim},{type_.storage_format.value})"
+        dim = type_.dim if type_.dim is not None else "*"
+        storage_format = (
+            type_.storage_format.value
+            if type_.storage_format is not None
+            else "*"
+        )
+        storage_type = (
+            type_.storage_type.value if type_.storage_type is not None else "*"
+        )
+        return f"VECTOR({dim},{storage_format},{storage_type})"
 
 
 class OracleCompiler(compiler.SQLCompiler):

sqlalchemy/dialects/oracle/cx_oracle.py

@@ -1234,6 +1234,9 @@ class OracleDialect_cx_oracle(OracleDialect):
             with dbapi_connection.cursor() as cursor:
                 cursor.execute(f"ALTER SESSION SET ISOLATION_LEVEL={level}")
 
+    def detect_autocommit_setting(self, dbapi_conn) -> bool:
+        return bool(dbapi_conn.autocommit)
+
     def _detect_decimal_char(self, connection):
         # we have the option to change this setting upon connect,
         # or just look at what it is upon connect and convert.

sqlalchemy/dialects/oracle/vector.py

@@ -13,6 +13,7 @@ import array
 from dataclasses import dataclass
 from enum import Enum
 from typing import Optional
+from typing import Union
 
 import sqlalchemy.types as types
 from sqlalchemy.types import Float
@@ -95,6 +96,27 @@ class VectorStorageFormat(Enum):
     """
 
 
+class VectorStorageType(Enum):
+    """Enum representing the vector type,
+
+    See :ref:`oracle_vector_datatype` for background.
+
+    .. versionadded:: 2.0.43
+
+    """
+
+    SPARSE = "SPARSE"
+    """
+    A Sparse vector is a vector which has zero value for
+    most of its dimensions.
+    """
+    DENSE = "DENSE"
+    """
+    A Dense vector is a vector where most, if not all, elements
+    hold meaningful values.
+    """
+
+
 @dataclass
 class VectorIndexConfig:
     """Define the configuration for Oracle VECTOR Index.
@@ -176,6 +198,39 @@ class VectorIndexConfig:
                 )
 
 
+class SparseVector:
+    """
+    Lightweight SQLAlchemy-side version of SparseVector.
+    This mimics oracledb.SparseVector.
+
+    .. versionadded:: 2.0.43
+
+    """
+
+    def __init__(
+        self,
+        num_dimensions: int,
+        indices: Union[list, array.array],
+        values: Union[list, array.array],
+    ):
+        if not isinstance(indices, array.array) or indices.typecode != "I":
+            indices = array.array("I", indices)
+        if not isinstance(values, array.array):
+            values = array.array("d", values)
+        if len(indices) != len(values):
+            raise TypeError("indices and values must be of the same length!")
+
+        self.num_dimensions = num_dimensions
+        self.indices = indices
+        self.values = values
+
+    def __str__(self):
+        return (
+            f"SparseVector(num_dimensions={self.num_dimensions}, "
+            f"size={len(self.indices)}, typecode={self.values.typecode})"
+        )
+
+
 class VECTOR(types.TypeEngine):
     """Oracle VECTOR datatype.
 
@@ -196,17 +251,22 @@ class VECTOR(types.TypeEngine):
         VectorStorageFormat.FLOAT64: "d",  # Double
     }
 
-    def __init__(self, dim=None, storage_format=None):
+    def __init__(self, dim=None, storage_format=None, storage_type=None):
         """Construct a VECTOR.
 
         :param dim: integer. The dimension of the VECTOR datatype. This
          should be an integer value.
 
         :param storage_format: VectorStorageFormat. The VECTOR storage
-         type format. This may be Enum values form
+         type format. This should be Enum values form
          :class:`.VectorStorageFormat` INT8, BINARY, FLOAT32, or FLOAT64.
 
+        :param storage_type: VectorStorageType. The Vector storage type. This
+         should be Enum values from :class:`.VectorStorageType` SPARSE or
+         DENSE.
+
         """
+
         if dim is not None and not isinstance(dim, int):
             raise TypeError("dim must be an interger")
         if storage_format is not None and not isinstance(
@@ -215,12 +275,22 @@ class VECTOR(types.TypeEngine):
             raise TypeError(
                 "storage_format must be an enum of type VectorStorageFormat"
             )
+        if storage_type is not None and not isinstance(
+            storage_type, VectorStorageType
+        ):
+            raise TypeError(
+                "storage_type must be an enum of type VectorStorageType"
+            )
+
         self.dim = dim
         self.storage_format = storage_format
+        self.storage_type = storage_type
 
     def _cached_bind_processor(self, dialect):
         """
-        Convert a list to a array.array before binding it to the database.
+        Converts a Python-side SparseVector instance into an
+        oracledb.SparseVectormor a compatible array format before
+        binding it to the database.
         """
 
         def process(value):
@@ -233,20 +303,48 @@ class VECTOR(types.TypeEngine):
                 value = array.array(typecode, value)
                 return value
 
+            # Convert SqlAlchemy SparseVector to oracledb SparseVector object
+            elif isinstance(value, SparseVector):
+                return dialect.dbapi.SparseVector(
+                    value.num_dimensions,
+                    value.indices,
+                    value.values,
+                )
+
             else:
-                raise TypeError("VECTOR accepts list or array.array()")
+                raise TypeError(
+                    """
+                    Invalid input for VECTOR: expected a list, an array.array,
+                    or a SparseVector object.
+                    """
+                )
 
         return process
 
     def _cached_result_processor(self, dialect, coltype):
         """
-        Convert a array.array to list before binding it to the database.
+        Converts database-returned values into Python-native representations.
+        If the value is an oracledb.SparseVector, it is converted into the
+        SQLAlchemy-side SparseVector class.
+        If the value is a array.array, it is converted to a plain Python list.
+
         """
 
         def process(value):
-            if isinstance(value, array.array):
+            if value is None:
+                return None
+
+            elif isinstance(value, array.array):
                 return list(value)
 
+            # Convert Oracledb SparseVector to SqlAlchemy SparseVector object
+            elif isinstance(value, dialect.dbapi.SparseVector):
+                return SparseVector(
+                    num_dimensions=value.num_dimensions,
+                    indices=value.indices,
+                    values=value.values,
+                )
+
         return process
 
     def _array_typecode(self, typecode):

sqlalchemy/dialects/postgresql/_psycopg_common.py

@@ -170,6 +170,9 @@ class _PGDialect_common_psycopg(PGDialect):
     def _do_autocommit(self, connection, value):
         connection.autocommit = value
 
+    def detect_autocommit_setting(self, dbapi_connection):
+        return bool(dbapi_connection.autocommit)
+
     def do_ping(self, dbapi_connection):
         before_autocommit = dbapi_connection.autocommit
 

sqlalchemy/dialects/postgresql/asyncpg.py

@@ -1117,6 +1117,9 @@ class PGDialect_asyncpg(PGDialect):
     def set_isolation_level(self, dbapi_connection, level):
         dbapi_connection.set_isolation_level(self._isolation_lookup[level])
 
+    def detect_autocommit_setting(self, dbapi_conn) -> bool:
+        return bool(dbapi_conn.autocommit)
+
     def set_readonly(self, connection, value):
         connection.readonly = value
 

sqlalchemy/dialects/postgresql/pg8000.py

@@ -540,6 +540,9 @@ class PGDialect_pg8000(PGDialect):
             cursor.execute("COMMIT")
             cursor.close()
 
+    def detect_autocommit_setting(self, dbapi_conn) -> bool:
+        return bool(dbapi_conn.autocommit)
+
     def set_readonly(self, connection, value):
         cursor = connection.cursor()
         try:

sqlalchemy/dialects/sqlite/base.py

@@ -396,10 +396,18 @@ new connections through the usage of events::
 
     @event.listens_for(Engine, "connect")
     def set_sqlite_pragma(dbapi_connection, connection_record):
+        # the sqlite3 driver will not set PRAGMA foreign_keys
+        # if autocommit=False; set to True temporarily
+        ac = dbapi_connection.autocommit
+        dbapi_connection.autocommit = True
+
         cursor = dbapi_connection.cursor()
         cursor.execute("PRAGMA foreign_keys=ON")
         cursor.close()
 
+        # restore previous autocommit setting
+        dbapi_connection.autocommit = ac
+
 .. warning::
 
     When SQLite foreign keys are enabled, it is **not possible**

sqlalchemy/dialects/sqlite/pysqlite.py

@@ -502,6 +502,9 @@ class SQLiteDialect_pysqlite(SQLiteDialect):
             dbapi_connection.isolation_level = ""
             return super().set_isolation_level(dbapi_connection, level)
 
+    def detect_autocommit_setting(self, dbapi_connection):
+        return dbapi_connection.isolation_level is None
+
     def on_connect(self):
         def regexp(a, b):
             if b is None:

sqlalchemy/engine/base.py

@@ -1112,10 +1112,16 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
         if self._still_open_and_dbapi_connection_is_valid:
             if self._echo:
                 if self._is_autocommit_isolation():
-                    self._log_info(
-                        "ROLLBACK using DBAPI connection.rollback(), "
-                        "DBAPI should ignore due to autocommit mode"
-                    )
+                    if self.dialect.skip_autocommit_rollback:
+                        self._log_info(
+                            "ROLLBACK will be skipped by "
+                            "skip_autocommit_rollback"
+                        )
+                    else:
+                        self._log_info(
+                            "ROLLBACK using DBAPI connection.rollback(); "
+                            "set skip_autocommit_rollback to prevent fully"
+                        )
                 else:
                     self._log_info("ROLLBACK")
             try:
@@ -1131,7 +1137,7 @@ class Connection(ConnectionEventsTarget, inspection.Inspectable["Inspector"]):
             if self._is_autocommit_isolation():
                 self._log_info(
                     "COMMIT using DBAPI connection.commit(), "
-                    "DBAPI should ignore due to autocommit mode"
+                    "has no effect due to autocommit mode"
                 )
             else:
                 self._log_info("COMMIT")

sqlalchemy/engine/create.py

@@ -468,6 +468,9 @@ def create_engine(url: Union[str, _url.URL], **kwargs: Any) -> Engine:
 
             :ref:`pool_reset_on_return`
 
+            :ref:`dbapi_autocommit_skip_rollback` - a more modern approach
+            to using connections with no transactional instructions
+
     :param pool_timeout=30: number of seconds to wait before giving
         up on getting a connection from the pool. This is only used
         with :class:`~sqlalchemy.pool.QueuePool`. This can be a float but is
@@ -524,6 +527,18 @@ def create_engine(url: Union[str, _url.URL], **kwargs: Any) -> Engine:
 
      .. versionadded:: 1.4
 
+    :param skip_autocommit_rollback: When True, the dialect will
+       unconditionally skip all calls to the DBAPI ``connection.rollback()``
+       method if the DBAPI connection is confirmed to be in "autocommit" mode.
+       The availability of this feature is dialect specific; if not available,
+       a ``NotImplementedError`` is raised by the dialect when rollback occurs.
+
+       .. seealso::
+
+            :ref:`dbapi_autocommit_skip_rollback`
+
+       .. versionadded:: 2.0.43
+
     :param use_insertmanyvalues: True by default, use the "insertmanyvalues"
      execution style for INSERT..RETURNING statements by default.
 

sqlalchemy/engine/default.py

@@ -307,6 +307,7 @@ class DefaultDialect(Dialect):
         # Linting.NO_LINTING constant
         compiler_linting: Linting = int(compiler.NO_LINTING),  # type: ignore
         server_side_cursors: bool = False,
+        skip_autocommit_rollback: bool = False,
         **kwargs: Any,
     ):
         if server_side_cursors:
@@ -331,6 +332,8 @@ class DefaultDialect(Dialect):
 
         self.dbapi = dbapi
 
+        self.skip_autocommit_rollback = skip_autocommit_rollback
+
         if paramstyle is not None:
             self.paramstyle = paramstyle
         elif self.dbapi is not None:
@@ -701,6 +704,10 @@ class DefaultDialect(Dialect):
         pass
 
     def do_rollback(self, dbapi_connection):
+        if self.skip_autocommit_rollback and self.detect_autocommit_setting(
+            dbapi_connection
+        ):
+            return
         dbapi_connection.rollback()
 
     def do_commit(self, dbapi_connection):

sqlalchemy/engine/interfaces.py

@@ -779,6 +779,14 @@ class Dialect(EventTarget):
     default_isolation_level: Optional[IsolationLevel]
     """the isolation that is implicitly present on new connections"""
 
+    skip_autocommit_rollback: bool
+    """Whether or not the :paramref:`.create_engine.skip_autocommit_rollback`
+    parameter was set.
+
+    .. versionadded:: 2.0.43
+
+    """
+
     # create_engine()  -> isolation_level  currently goes here
     _on_connect_isolation_level: Optional[IsolationLevel]
 
@@ -2481,6 +2489,30 @@ class Dialect(EventTarget):
 
         raise NotImplementedError()
 
+    def detect_autocommit_setting(self, dbapi_conn: DBAPIConnection) -> bool:
+        """Detect the current autocommit setting for a DBAPI connection.
+
+        :param dbapi_connection: a DBAPI connection object
+        :return: True if autocommit is enabled, False if disabled
+        :rtype: bool
+
+        This method inspects the given DBAPI connection to determine
+        whether autocommit mode is currently enabled. The specific
+        mechanism for detecting autocommit varies by database dialect
+        and DBAPI driver, however it should be done **without** network
+        round trips.
+
+        .. note::
+
+            Not all dialects support autocommit detection. Dialects
+            that do not support this feature will raise
+            :exc:`NotImplementedError`.
+
+        """
+        raise NotImplementedError(
+            "This dialect cannot detect autocommit on a DBAPI connection"
+        )
+
     def get_default_isolation_level(
         self, dbapi_conn: DBAPIConnection
     ) -> IsolationLevel:

sqlalchemy/engine/result.py

@@ -2013,7 +2013,7 @@ class MappingResult(_WithKeys, FilterResult[RowMapping]):
         return self
 
     def columns(self, *col_expressions: _KeyIndexType) -> Self:
-        r"""Establish the columns that should be returned in each row."""
+        """Establish the columns that should be returned in each row."""
         return self._column_slices(col_expressions)
 
     def partitions(

sqlalchemy/orm/descriptor_props.py

@@ -393,7 +393,9 @@ class CompositeProperty(
             self.composite_class = argument
 
         if is_dataclass(self.composite_class):
-            self._setup_for_dataclass(registry, cls, originating_module, key)
+            self._setup_for_dataclass(
+                decl_scan, registry, cls, originating_module, key
+            )
         else:
             for attr in self.attrs:
                 if (
@@ -437,6 +439,7 @@ class CompositeProperty(
     @util.preload_module("sqlalchemy.orm.decl_base")
     def _setup_for_dataclass(
         self,
+        decl_scan: _ClassScanMapperConfig,
         registry: _RegistryType,
         cls: Type[Any],
         originating_module: Optional[str],
@@ -464,6 +467,7 @@ class CompositeProperty(
 
             if isinstance(attr, MappedColumn):
                 attr.declarative_scan_for_composite(
+                    decl_scan,
                     registry,
                     cls,
                     originating_module,

sqlalchemy/orm/loading.py

@@ -39,6 +39,7 @@ from .base import PassiveFlag
 from .context import FromStatement
 from .context import ORMCompileState
 from .context import QueryContext
+from .strategies import SelectInLoader
 from .util import _none_set
 from .util import state_str
 from .. import exc as sa_exc
@@ -1309,15 +1310,18 @@ def _load_subclass_via_in(
         if context.populate_existing:
             q2 = q2.execution_options(populate_existing=True)
 
-        context.session.execute(
-            q2,
-            dict(
-                primary_keys=[
-                    state.key[1][0] if zero_idx else state.key[1]
-                    for state, load_attrs in states
-                ]
-            ),
-        ).unique().scalars().all()
+        while states:
+            chunk = states[0 : SelectInLoader._chunksize]
+            states = states[SelectInLoader._chunksize :]
+            context.session.execute(
+                q2,
+                dict(
+                    primary_keys=[
+                        state.key[1][0] if zero_idx else state.key[1]
+                        for state, load_attrs in chunk
+                    ]
+                ),
+            ).unique().scalars().all()
 
     return do_load
 

sqlalchemy/orm/persistence.py

@@ -1374,7 +1374,13 @@ def _emit_post_update_statements(
             )
 
             rows += c.rowcount
-            for state, state_dict, mapper_rec, connection, params in records:
+            for i, (
+                state,
+                state_dict,
+                mapper_rec,
+                connection,
+                params,
+            ) in enumerate(records):
                 _postfetch_post_update(
                     mapper_rec,
                     uowtransaction,
@@ -1382,7 +1388,7 @@ def _emit_post_update_statements(
                     state,
                     state_dict,
                     c,
-                    c.context.compiled_parameters[0],
+                    c.context.compiled_parameters[i],
                 )
 
         if check_rowcount:

sqlalchemy/orm/properties.py

@@ -663,20 +663,12 @@ class MappedColumn(
         # Column will be merged into it in _init_column_for_annotation().
         return MappedColumn()
 
-    def declarative_scan(
+    def _adjust_for_existing_column(
         self,
         decl_scan: _ClassScanMapperConfig,
-        registry: _RegistryType,
-        cls: Type[Any],
-        originating_module: Optional[str],
         key: str,
-        mapped_container: Optional[Type[Mapped[Any]]],
-        annotation: Optional[_AnnotationScanType],
-        extracted_mapped_annotation: Optional[_AnnotationScanType],
-        is_dataclass_field: bool,
-    ) -> None:
-        column = self.column
-
+        given_column: Column[_T],
+    ) -> Column[_T]:
         if (
             self._use_existing_column
             and decl_scan.inherits
@@ -688,10 +680,31 @@ class MappedColumn(
                 )
             supercls_mapper = class_mapper(decl_scan.inherits, False)
 
-            colname = column.name if column.name is not None else key
-            column = self.column = supercls_mapper.local_table.c.get(  # type: ignore[assignment] # noqa: E501
-                colname, column
+            colname = (
+                given_column.name if given_column.name is not None else key
             )
+            given_column = supercls_mapper.local_table.c.get(  # type: ignore[assignment] # noqa: E501
+                colname, given_column
+            )
+        return given_column
+
+    def declarative_scan(
+        self,
+        decl_scan: _ClassScanMapperConfig,
+        registry: _RegistryType,
+        cls: Type[Any],
+        originating_module: Optional[str],
+        key: str,
+        mapped_container: Optional[Type[Mapped[Any]]],
+        annotation: Optional[_AnnotationScanType],
+        extracted_mapped_annotation: Optional[_AnnotationScanType],
+        is_dataclass_field: bool,
+    ) -> None:
+        column = self.column
+
+        column = self.column = self._adjust_for_existing_column(
+            decl_scan, key, self.column
+        )
 
         if column.key is None:
             column.key = key
@@ -708,6 +721,8 @@ class MappedColumn(
 
         self._init_column_for_annotation(
             cls,
+            decl_scan,
+            key,
             registry,
             extracted_mapped_annotation,
             originating_module,
@@ -716,6 +731,7 @@ class MappedColumn(
     @util.preload_module("sqlalchemy.orm.decl_base")
     def declarative_scan_for_composite(
         self,
+        decl_scan: _ClassScanMapperConfig,
         registry: _RegistryType,
         cls: Type[Any],
         originating_module: Optional[str],
@@ -726,12 +742,14 @@ class MappedColumn(
         decl_base = util.preloaded.orm_decl_base
         decl_base._undefer_column_name(param_name, self.column)
         self._init_column_for_annotation(
-            cls, registry, param_annotation, originating_module
+            cls, decl_scan, key, registry, param_annotation, originating_module
         )
 
     def _init_column_for_annotation(
         self,
         cls: Type[Any],
+        decl_scan: _ClassScanMapperConfig,
+        key: str,
         registry: _RegistryType,
         argument: _AnnotationScanType,
         originating_module: Optional[str],
@@ -778,6 +796,11 @@ class MappedColumn(
             use_args_from = None
 
         if use_args_from is not None:
+
+            self.column = use_args_from._adjust_for_existing_column(
+                decl_scan, key, self.column
+            )
+
             if (
                 not self._has_insert_default
                 and use_args_from.column.default is not None

sqlalchemy/sql/functions.py

@@ -745,9 +745,7 @@ class FunctionElement(Executable, ColumnElement[_T], FromClause, Generative):
         # expressions against getitem.  This may need to be made
         # more portable if in the future we support other DBs
         # besides postgresql.
-        if against is operators.getitem and isinstance(
-            self.type, sqltypes.ARRAY
-        ):
+        if against in (operators.getitem, operators.json_getitem_op):
             return Grouping(self)
         else:
             return super().self_group(against=against)

sqlalchemy/testing/requirements.py

@@ -1033,6 +1033,13 @@ class SuiteRequirements(Requirements):
         """target dialect supports 'AUTOCOMMIT' as an isolation_level"""
         return exclusions.closed()
 
+    @property
+    def skip_autocommit_rollback(self):
+        """target dialect supports the detect_autocommit_setting() method and
+        uses the default implementation of do_rollback()"""
+
+        return exclusions.closed()
+
     @property
     def isolation_level(self):
         """target dialect supports general isolation level settings.

sqlalchemy/testing/suite/test_dialect.py

@@ -17,6 +17,7 @@ from .. import eq_
 from .. import fixtures
 from .. import is_not_none
 from .. import is_true
+from .. import mock
 from .. import ne_
 from .. import provide_metadata
 from ..assertions import expect_raises
@@ -293,7 +294,11 @@ class AutocommitIsolationTest(fixtures.TablesTest):
             test_needs_acid=True,
         )
 
-    def _test_conn_autocommits(self, conn, autocommit):
+    def _test_conn_autocommits(self, conn, autocommit, ensure_table=False):
+        if ensure_table:
+            self.tables.some_table.create(conn, checkfirst=True)
+            conn.commit()
+
         trans = conn.begin()
         conn.execute(
             self.tables.some_table.insert(), {"id": 1, "data": "some data"}
@@ -336,6 +341,37 @@ class AutocommitIsolationTest(fixtures.TablesTest):
         )
         self._test_conn_autocommits(conn, False)
 
+    @testing.requires.skip_autocommit_rollback
+    @testing.variation("autocommit_setting", ["false", "engine", "option"])
+    @testing.variation("block_rollback", [True, False])
+    def test_autocommit_block(
+        self, testing_engine, autocommit_setting, block_rollback
+    ):
+        kw = {}
+        if bool(block_rollback):
+            kw["skip_autocommit_rollback"] = True
+        if autocommit_setting.engine:
+            kw["isolation_level"] = "AUTOCOMMIT"
+
+        engine = testing_engine(options=kw)
+
+        conn = engine.connect()
+        if autocommit_setting.option:
+            conn.execution_options(isolation_level="AUTOCOMMIT")
+        self._test_conn_autocommits(
+            conn,
+            autocommit_setting.engine or autocommit_setting.option,
+            ensure_table=True,
+        )
+        with mock.patch.object(
+            conn.connection, "rollback", wraps=conn.connection.rollback
+        ) as check_rollback:
+            conn.close()
+        if autocommit_setting.false or not block_rollback:
+            eq_(check_rollback.mock_calls, [mock.call()])
+        else:
+            eq_(check_rollback.mock_calls, [])
+
     @testing.requires.independent_readonly_connections
     @testing.variation("use_dialect_setting", [True, False])
     def test_dialect_autocommit_is_restored(

{sqlalchemy-2.0.42.dist-info → sqlalchemy-2.0.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SQLAlchemy
-Version: 2.0.42
+Version: 2.0.43
 Summary: Database Abstraction Library
 Home-page: https://www.sqlalchemy.org
 Author: Mike Bayer

{sqlalchemy-2.0.42.dist-info → sqlalchemy-2.0.43.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sqlalchemy/__init__.py,sha256=B2OJyoEJaSOLgw9AIQNETdOyh7MVzj2sPZN_oWvk-1A,12659
+sqlalchemy/__init__.py,sha256=Oi26seKKS4YLZt2VPHQvkIIoTKAcEWD4BCjHQZRG8BE,12659
 sqlalchemy/events.py,sha256=VBRvtckn9JS3tfUfi6UstqUrvQ15J2xamcDByFysIrI,525
 sqlalchemy/exc.py,sha256=AjFBCrOl_V4vQdGegn72Y951RSRMPL6T5qjxnFTGFbM,23978
 sqlalchemy/inspection.py,sha256=qKEKG37N1OjxpQeVzob1q9VwWjBbjI1x0movJG7fYJ4,5063
@@ -9,7 +9,7 @@ sqlalchemy/types.py,sha256=Iq_rKisaj_zhHtzD2R2cxvg3jkug5frikbkcKG0S4Lg,3166
 sqlalchemy/connectors/__init__.py,sha256=YeSHsOB0YhdM6jZUvHFQFwKqNXO02MlklmGW0yCywjI,476
 sqlalchemy/connectors/aioodbc.py,sha256=-OKbnvR-kLCKHyrOIBkAZwTASAbQZ5qmrozm0dwbtNE,5577
 sqlalchemy/connectors/asyncio.py,sha256=OPhwvKQo7l3CUSY7YsL3W8oBqc_zQIAytIvqLjZLwTA,10122
-sqlalchemy/connectors/pyodbc.py,sha256=VaNPMLmkEiNteyPUIzwVIGRSjN9DZVZdJakHDvx5jWI,8471
+sqlalchemy/connectors/pyodbc.py,sha256=ZGWBmYYYVgqUHjex3d_lYHZyAhQJGowp9cWGYnj1200,8618
 sqlalchemy/cyextension/__init__.py,sha256=4npVIjitKfUs0NQ6f3UdQBDq4ipJ0_ZNB2mpKqtc5ik,244
 sqlalchemy/cyextension/collections.pyx,sha256=L7DZ3DGKpgw2MT2ZZRRxCnrcyE5pU1NAFowWgAzQPEc,12571
 sqlalchemy/cyextension/immutabledict.pxd,sha256=3x3-rXG5eRQ7bBnktZ-OJ9-6ft8zToPmTDOd92iXpB0,291
@@ -29,8 +29,8 @@ sqlalchemy/dialects/mssql/provision.py,sha256=P1tqxZ4f6Oeqn2gNi7dXl82LRLCg1-OB4e
 sqlalchemy/dialects/mssql/pymssql.py,sha256=C7yAs3Pw81W1KTVNc6_0sHQuYlJ5iH82vKByY4TkB1g,4097
 sqlalchemy/dialects/mssql/pyodbc.py,sha256=CnO7KDWxbxb7AoZhp_PMDBvVSMuzwq1h4Cav2IWFWDo,27173
 sqlalchemy/dialects/mysql/__init__.py,sha256=ropOMUWrAcL-Q7h-9jQ_tb3ISAFIsNRQ8YVXvn0URl0,2206
-sqlalchemy/dialects/mysql/aiomysql.py,sha256=nkmVq3twbeN2g0PMe0oBOy_UhK-MqYWqXTD4sC9aYTE,7624
-sqlalchemy/dialects/mysql/asyncmy.py,sha256=9hc8GoYzmjW7ypWJCJiwF6VSdl9kEX43c9b5SknERaw,6989
+sqlalchemy/dialects/mysql/aiomysql.py,sha256=XpHS7KvZF_XQFlghvqyZfPuLD890M7GTgMLCaeXA67E,7728
+sqlalchemy/dialects/mysql/asyncmy.py,sha256=kuX02tRZ-0kKbwRgs3dL5T-mRyc5oBSFoIzQDgaHgYk,7093
 sqlalchemy/dialects/mysql/base.py,sha256=V2CE2XB6eiFG3doNdzH3NZPhgXgt3OL7QN8F3dg_9Pg,137763
 sqlalchemy/dialects/mysql/cymysql.py,sha256=ihH4kZ273nvf0R0p8keD71ZIaTXRHyZePXMlobwgbpI,3215
 sqlalchemy/dialects/mysql/dml.py,sha256=VjnTobe_SBNF2RN6tvqa5LOn-9x4teVUyzUedZkOmdc,7768
@@ -38,27 +38,27 @@ sqlalchemy/dialects/mysql/enumerated.py,sha256=si2hGv5jMNGS78n_JDgswIhbBZuTqjwbx
 sqlalchemy/dialects/mysql/expression.py,sha256=C8LhU-CM6agqKCS1tl1_ChSqwZbqt3zP_dSGBqgBgLg,4241
 sqlalchemy/dialects/mysql/json.py,sha256=ckYT_lihvqr28iHJTUUwvPPUIoYVLL_wUXWFDTCna_M,2806
 sqlalchemy/dialects/mysql/mariadb.py,sha256=yaiZnnbjfrBqHm1ykaRSFYKrrYUqu-GBYvt97EGYSzs,1886
-sqlalchemy/dialects/mysql/mariadbconnector.py,sha256=QgPYt1AmbG2PwpQkMdzLtQY3V8y8AQrg-N0Dg-qFsBk,10263
-sqlalchemy/dialects/mysql/mysqlconnector.py,sha256=lcBprcbcs-XyfofG-BmNBAY3Dztp0vUmCHQbOQIanc4,9975
-sqlalchemy/dialects/mysql/mysqldb.py,sha256=zWerlr1AipnHjZbWG9wr-8k6lusPmQu_yWHuRmGCKNQ,9790
+sqlalchemy/dialects/mysql/mariadbconnector.py,sha256=lJuS3euMlVBbJDJ10ntqe3TnrjzneLEUlE8sLZl6Qoc,10385
+sqlalchemy/dialects/mysql/mysqlconnector.py,sha256=aaAiF32rQVoLNVIdgGKHMsnMei--0ig3OqmhWq45MrA,10097
+sqlalchemy/dialects/mysql/mysqldb.py,sha256=8wIxcxQxT-X6nywLJkjg9_JdIKGYOhlrtVL8lP_WFcM,9943
 sqlalchemy/dialects/mysql/provision.py,sha256=MaQ9eeHnRL4EXAebIInwarCIiDbYcz_sMCss3wyV12Q,3717
 sqlalchemy/dialects/mysql/pymysql.py,sha256=Qlc9XToIqAfHz0c_ODs97uk1TlV1ZrEl_TidTjoeByU,4886
 sqlalchemy/dialects/mysql/pyodbc.py,sha256=v-Zo4M7blxdff--KJiIantCwbPO6H-GBkNCTN4nBgU4,5111
 sqlalchemy/dialects/mysql/reflection.py,sha256=CBxBiv1mCLLNHz-I8hgJKACTF3K0eYEpWd0ndCBCq5I,24690
 sqlalchemy/dialects/mysql/reserved_words.py,sha256=iG6zb78sn-RdqWQRk2F_Tuufk5tUodkcoHbxTdgZYkw,9236
 sqlalchemy/dialects/mysql/types.py,sha256=lAkkNRVPBHP8H7AQQ7NykfJ8YxgdUDAHkfd7qD-Lwvo,26459
-sqlalchemy/dialects/oracle/__init__.py,sha256=0CN5PU88L9wND0qZhAYF3H6Lv7m5tSauD1SgE3hzQV8,1782
-sqlalchemy/dialects/oracle/base.py,sha256=hNn633atVfNzEvuiX7P-dZ8nBY68zOWWCn4S7nMrEsk,137057
-sqlalchemy/dialects/oracle/cx_oracle.py,sha256=ohENTgLxGUfobRH3K8KdeZgBRPG1rX3vY-ph9blj-2g,56612
+sqlalchemy/dialects/oracle/__init__.py,sha256=5qrJcFTF3vgB9B4PkwBJj3iXE7P57LdaHNkxMa1NXug,1898
+sqlalchemy/dialects/oracle/base.py,sha256=zEl885-lRs07FGdWFuSzBfa1FqrUPT7l2wpcBr9joIs,139156
+sqlalchemy/dialects/oracle/cx_oracle.py,sha256=mYrXD0nJzuTY1h878b50fNXIUBgjc9Q1LJjjY1VHx3w,56717
 sqlalchemy/dialects/oracle/dictionary.py,sha256=J7tGVE0KyUPZKpPLOary3HdDq1DWd29arF5udLgv8_o,19519
 sqlalchemy/dialects/oracle/oracledb.py,sha256=veqto1AUIbSxRmpUQin0ysMV8Y6sWAkzXt7W8IIl118,33771
 sqlalchemy/dialects/oracle/provision.py,sha256=ga1gNQZlXZKk7DYuYegllUejJxZXRKDGa7dbi_S_poc,8313
 sqlalchemy/dialects/oracle/types.py,sha256=axN6Yidx9tGRIUAbDpBrhMWXE-C8jSllFpTghpGOOzU,9058
-sqlalchemy/dialects/oracle/vector.py,sha256=kG78FYA4MKGmSdPrVduzht3PetJ1pewE3_7uPewPn-M,7861
+sqlalchemy/dialects/oracle/vector.py,sha256=YtN7E5TbDIQR2FCICaSeeaOnvzHP_O0mXNq1gk02S4Q,10874
 sqlalchemy/dialects/postgresql/__init__.py,sha256=kD8W-SV5e2CesvWg2MQAtncXuZFwGPfR_UODvmRXE08,3892
-sqlalchemy/dialects/postgresql/_psycopg_common.py,sha256=znHkQBGgbR9fYgBHI2Qd9O-RhSe1bKkkX2zZQih_ba4,5674
+sqlalchemy/dialects/postgresql/_psycopg_common.py,sha256=h4JmkHWxy_Nspn6Bi9YKpa9l0OkwInwQzYKue-fJnVA,5783
 sqlalchemy/dialects/postgresql/array.py,sha256=FyyJ1f3RSAhHtgxKydfMkUAGEh-LJyLOZ31jiAdDo74,16956
-sqlalchemy/dialects/postgresql/asyncpg.py,sha256=mEc7aj5wmtJNBF-xRCJ6PuoxJ0wpN_bcE99sct-kd4s,41443
+sqlalchemy/dialects/postgresql/asyncpg.py,sha256=QPvyV6YYZ9--ULoMYC5pl7axct79H8DbYrKAUQASqzg,41548
 sqlalchemy/dialects/postgresql/base.py,sha256=RDuehOZL3hLPhq4_7G-91BgAM9LeToHiiIU-RjFGVmU,186421
 sqlalchemy/dialects/postgresql/dml.py,sha256=2SmyMeYveAgm7OnT_CJvwad2nh8BP37yT6gFs8dBYN8,12126
 sqlalchemy/dialects/postgresql/ext.py,sha256=voxpAz-zoCOO-fjpCzrw7UASzNIvdz2u4kFSuGcshlI,17347
@@ -66,7 +66,7 @@ sqlalchemy/dialects/postgresql/hstore.py,sha256=wR4gmvfQWPssHwYTXEsPJTb4LkBS6x4e
 sqlalchemy/dialects/postgresql/json.py,sha256=YO6yuDnUKh-mHNtc7DavFMpYNUrJ_dNb24gw333uH0M,12842
 sqlalchemy/dialects/postgresql/named_types.py,sha256=D1WFTcxE-PKYRaB75gWvnAvpgGJRTcFkW9nSGpC4WCo,17812
 sqlalchemy/dialects/postgresql/operators.py,sha256=ay3ckNsWtqDjxDseTdKMGGqYVzST6lmfhbbYHG_bxCw,2808
-sqlalchemy/dialects/postgresql/pg8000.py,sha256=RAykzZuO3Anr6AsyK2JYr7CPb2pru6WtkrX2phCyCGU,18638
+sqlalchemy/dialects/postgresql/pg8000.py,sha256=r6Lg5tgwuf4FE_RA_kHcfHPW5GXUdNWWr3E846Z4aI0,18743
 sqlalchemy/dialects/postgresql/pg_catalog.py,sha256=wnzFm9S0JFag1TBdySDJH3VOFSkJWmwAjVcIAQ25jHg,9999
 sqlalchemy/dialects/postgresql/provision.py,sha256=7pg9-nOnaK5XBzqByXNPuvi3rxtnRa3dJxdSPVq4eeA,5770
 sqlalchemy/dialects/postgresql/psycopg.py,sha256=k7zXsJj35aOXCrhsbMxwTQX5JWegrqirFJ1Hgbq-GjQ,23326
@@ -76,27 +76,27 @@ sqlalchemy/dialects/postgresql/ranges.py,sha256=rsvhfZ63OVtHHeBDXb_6hULg0HkVx18h
 sqlalchemy/dialects/postgresql/types.py,sha256=oKhDsFiITKbZcCP66L3dhif54pmsFvVfv-MZQWA3sYo,7629
 sqlalchemy/dialects/sqlite/__init__.py,sha256=6Xcz3nPsl8lqCcZ4-VzPRmkMrkKgAp2buKsClZelU7c,1182
 sqlalchemy/dialects/sqlite/aiosqlite.py,sha256=eZW4NFpLS6z02keIHeJLI5tFUkzhn0MpS8r2kkl0G0I,14619
-sqlalchemy/dialects/sqlite/base.py,sha256=BrUrYfBlxus3cYsEhw0N_GdDRI5gQCxV6Bz_Y8APiWI,102569
+sqlalchemy/dialects/sqlite/base.py,sha256=rRYahtQDySw-4v6ljEomUdvjigGTNXqaqPuiQ5eOpa4,102859
 sqlalchemy/dialects/sqlite/dml.py,sha256=4N8qh06RuMphLoQgWw7wv5nXIrka57jIFvK2x9xTZqg,9138
 sqlalchemy/dialects/sqlite/json.py,sha256=A62xPyLRZxl2hvgTMM92jd_7jlw9UE_4Y6Udqt-8g04,2777
 sqlalchemy/dialects/sqlite/provision.py,sha256=VhqDjDALqxKQY_3Z3hjzkmPQJ-vtk2Dkk1A4qLTs-G8,5596
 sqlalchemy/dialects/sqlite/pysqlcipher.py,sha256=di8rYryfL0KAn3pRGepmunHyIRGy-4Hhr-2q_ehPzss,5371
-sqlalchemy/dialects/sqlite/pysqlite.py,sha256=xUM3jL_VKVRLWeADFTPqETRE0KhSK7Gin3Two5hbG_c,25883
+sqlalchemy/dialects/sqlite/pysqlite.py,sha256=42jPDi1nZ_9YVKKWaKnkurL8NOFUX_8Rbn7baqRw0J8,25999
 sqlalchemy/engine/__init__.py,sha256=EF4haWCPu95WtWx1GzcHRJ_bBmtJMznno3I2TQ-ZIHE,2818
 sqlalchemy/engine/_py_processors.py,sha256=7QxgkVOd5h1Qd22qFh-pPZdM7RBRzNjj8lWAMWrilcI,3744
 sqlalchemy/engine/_py_row.py,sha256=yNdrZe36yw6mO7x0OEbG0dGojH7CQkNReIwn9LMUPUs,3787
 sqlalchemy/engine/_py_util.py,sha256=Nvd4pVdXRs89khRevK-Ux4Y9p2f2vnALboNrSwhqS1U,2465
-sqlalchemy/engine/base.py,sha256=h2f-6jF3Jl-nPoKVDKMxQwsfMzMuUT7adnFCGkux8fc,122809
+sqlalchemy/engine/base.py,sha256=aNp2tGNBWlBz2pHiOveJ3PeaJRDJlLknekUQ50MJDjU,123090
 sqlalchemy/engine/characteristics.py,sha256=PepmGApo1sL01dS1qtSbmHplu9ZCdtuSegiGI7L7NZY,4765
-sqlalchemy/engine/create.py,sha256=4gFkqV7fgJbI1906DC4zDgFFX1-xJQ96GIHIrQuc-w4,33217
+sqlalchemy/engine/create.py,sha256=uIAiU-ANj7fk_6A3dbJw_SEU8Qfd0_YF8yEHGxD0r1g,33847
 sqlalchemy/engine/cursor.py,sha256=63KLS-IKKAYh2uADJytpT1i9-qpG9E0iVBIcKTtKkwI,76567
-sqlalchemy/engine/default.py,sha256=-KVoJGYTC2ypBG0CaNz7001rXOkyearAl8uyatFHDBk,85471
+sqlalchemy/engine/default.py,sha256=PpySUqbAliGjw80ZxhDdZwyiFEMCpNPcC1XmyJynyEE,85721
 sqlalchemy/engine/events.py,sha256=4_e6Ip32ar2Eb27R4ipamiKC-7Tpg4lVz3txabhT5Rc,37400
-sqlalchemy/engine/interfaces.py,sha256=jOKv5vnSsXmWkImNldqviuHDfCnBEu6wpKuzTFyLaiY,114028
+sqlalchemy/engine/interfaces.py,sha256=fNGMov1byIOkPxh7dJervp-UUNyHHm3jpIB0HrCMucc,115119
 sqlalchemy/engine/mock.py,sha256=L07bSIkgEbIkih-pYvFWh7k7adHVp5tBFBekKlD7GHs,4156
 sqlalchemy/engine/processors.py,sha256=XK32bULBkuVVRa703u4-SrTCDi_a18Dxq1M09QFBEPw,2379
 sqlalchemy/engine/reflection.py,sha256=QNOAXvKtdzVddpbkMOyM380y3olKdJKQkmF0Bfwia-Q,75565
-sqlalchemy/engine/result.py,sha256=9Uhu3rDK78kMZRvig7_fg_Z4uOlZgRq4n9HPusLNXaw,77806
+sqlalchemy/engine/result.py,sha256=46J3rP0ZwDwsqU-4CAaEHXTpx8OqCEP9Dy4LQwtHUEg,77805
 sqlalchemy/engine/row.py,sha256=BPtAwsceiRxB9ANpDNM24uQ1M_Zs0xFkSXoKR_I8xyY,12031
 sqlalchemy/engine/strategies.py,sha256=3DixBdeTa824XjuID2o7UxIyg7GyNwdBI8hOOT0SQnc,439
 sqlalchemy/engine/url.py,sha256=GJfZo0KtbMtkOIHBPI_KcKASsyrI5UYkX-UoN62FQxc,31067
@@ -149,7 +149,7 @@ sqlalchemy/orm/context.py,sha256=9OOJxvXJ_01Sd5-wny-WqVGtak4IA78TyLG_zMOHYmA,115
 sqlalchemy/orm/decl_api.py,sha256=ViRNRYA1jXcxJCX2UPW7ugymozqbV55WbIj1c96XPpQ,65038
 sqlalchemy/orm/decl_base.py,sha256=N13zJJ0Yejcwu0yOWz8WI38ab56WTeHioYr2PlRCal0,83486
 sqlalchemy/orm/dependency.py,sha256=eiYTsSnW94uGXEFQWj6-KFn25ivz_a2dPN3P6_nMou4,47619
-sqlalchemy/orm/descriptor_props.py,sha256=XInDpnCcTu6urMleOFrikfTMjf-pi9mErOy-LQqM-rk,37680
+sqlalchemy/orm/descriptor_props.py,sha256=dh97zKu5-OHDNEhHA3H2YHwdpT8wVT06faeHDzED4pk,37795
 sqlalchemy/orm/dynamic.py,sha256=Z4GpcVL8rM8gi0bytQOZXw-_kKi-sExbRWGjU30dK3g,9816
 sqlalchemy/orm/evaluator.py,sha256=PKrUW1zEOvmv1XEgc_hBdYqNcyk4zjWr_rJhCEQBFIc,12353
 sqlalchemy/orm/events.py,sha256=rdqxmaiaZ7MZ5LQwY5cz6irLkGpJzr1C66zkTsW-QgA,127780
@@ -157,12 +157,12 @@ sqlalchemy/orm/exc.py,sha256=V7cUPl9Kw4qZHLyjOvU1C5WMJ-0MKpNN10qM0C0YG5Y,7636
 sqlalchemy/orm/identity.py,sha256=5NFtF9ZPZWAOmtOqCPyVX2-_pQq9A5XeN2ns3Wirpv8,9249
 sqlalchemy/orm/instrumentation.py,sha256=WhElvvOWOn3Fuc-Asc5HmcKDX6EzFtBleLJKPZEc5A0,24321
 sqlalchemy/orm/interfaces.py,sha256=C0RL0aOVB7E14EVp7MD9C55F2yrOfuOMZ0X-oZg3FCg,49072
-sqlalchemy/orm/loading.py,sha256=6Rd1hWtBPm7SfCUpjPQrcoUg_DSCcfhO8Qhz7SScjRE,58277
+sqlalchemy/orm/loading.py,sha256=SMv9Q5bC-kdvsBpOqBNGqNWlL3I75fxByUeEpLC3qtg,58488
 sqlalchemy/orm/mapped_collection.py,sha256=FAqaTlOUCYqdws2KR_fW0T8mMWIrLuAxJGU5f4W1aGs,19682
 sqlalchemy/orm/mapper.py,sha256=-7q3rHqj3x_acv6prq3sDEXZmHx7kGSV9G-gW_JwaX4,171834
 sqlalchemy/orm/path_registry.py,sha256=tRk3osC5BmU7kkcKJCeeibpg2witjyVzO0rX0pu8vmc,25914
-sqlalchemy/orm/persistence.py,sha256=Uz45Cwxi7FnNiSk2crbh3TzV7b9kb85vmcvOwy5NVmw,61701
-sqlalchemy/orm/properties.py,sha256=bGhcG0Rfz_unF1ixz6WCxl1svqhfcTHbTG8kOGdfmKo,29485
+sqlalchemy/orm/persistence.py,sha256=laKaHW7XsVDYhXfDLnxqAJ5lPB8vhUZ0lEhLvtx-fb4,61812
+sqlalchemy/orm/properties.py,sha256=yXxd40V25FIF9vSEev-AxH58yZie8mZMCGQtgFmoUe8,30127
 sqlalchemy/orm/query.py,sha256=hPLslLL50lThw--5G8l3GtPgEdIY07hqIDOEO-0-wT8,118724
 sqlalchemy/orm/relationships.py,sha256=t3yqixZ41chMVOnmelNaps7jwj5vwN9dZFSB0gKK9Pw,128763
 sqlalchemy/orm/scoping.py,sha256=I_-BL8xAFQsZraFtA1wf5wgZ1WywBwBk-9OwiSAjPTM,78600
@@ -198,7 +198,7 @@ sqlalchemy/sql/dml.py,sha256=hUubKQK2dT91uMXyWuK1OpdJ6L4R_VyBw_rKH82lt7U,66232
 sqlalchemy/sql/elements.py,sha256=E0lCoqQJbWwQ34xdhdxGXqGcFgrvla_xrnSpWgs4Uwo,178317
 sqlalchemy/sql/events.py,sha256=iWjc_nm1vClDBLg4ZhDnY75CkBdnlDPSPe0MGBSmbiM,18312
 sqlalchemy/sql/expression.py,sha256=CsOkmAQgaB-Rnwe7eK60FdBC5R9kY5pczCGrVw2BwGs,7583
-sqlalchemy/sql/functions.py,sha256=Vvbs2ZlNmfZKfsoTRAB9MZ-cdm1AUtYc4h017HjNVtg,64861
+sqlalchemy/sql/functions.py,sha256=DQkV7asOlWaBtFTqRIC663oNkloy5EUhHexjo87GtUY,64826
 sqlalchemy/sql/lambdas.py,sha256=W5b75ojie3EOm7poR27qsnQHQYdz-NxfSrgb5ATT2H0,49401
 sqlalchemy/sql/naming.py,sha256=5Tk6nm4xqy8d9gzXzDvdiqqS7IptUaf1d7IuVdslplU,6855
 sqlalchemy/sql/operators.py,sha256=h5bgu31gukGdsYsN_0-1C7IGAdSCFpBxuRjOUnu1Two,76792
@@ -221,7 +221,7 @@ sqlalchemy/testing/exclusions.py,sha256=0Byf3DIMQXN0-HOS6M2MPJ-fOm_n5MzE1yIfHgE0
 sqlalchemy/testing/pickleable.py,sha256=G3L0xL9OtbX7wThfreRjWd0GW7q0kUKcTUuCN5ETGno,2833
 sqlalchemy/testing/profiling.py,sha256=SWhWiZImJvDsNn0rQyNki70xdNxZL53ZI98ihxiykbQ,10148
 sqlalchemy/testing/provision.py,sha256=6r2FTnm-t7u8MMbWo7eMhAH3qkL0w0WlmE29MUSEIu4,14702
-sqlalchemy/testing/requirements.py,sha256=v2nw1Agz6wuh4QR-2b0qRImhLeMCb4khWWwmW3d9HGw,55528
+sqlalchemy/testing/requirements.py,sha256=3u8lfzSOLE-_QUD6iHkhzRRbXDyEucmz2T8VRO8QG08,55757
 sqlalchemy/testing/schema.py,sha256=IImFumAdpzOyoKAs0WnaGakq8D3sSU4snD9W4LVOV3s,6513
 sqlalchemy/testing/util.py,sha256=BuA4q-8cmNhrUVqPP35Rr15MnYGSjmW0hmUdS1SI0_I,14526
 sqlalchemy/testing/warnings.py,sha256=sj4vfTtjodcfoX6FPH_Zykb4fomjmgqIYj81QPpSwH8,1546
@@ -238,7 +238,7 @@ sqlalchemy/testing/suite/__init__.py,sha256=S8TLwTiif8xX67qlZUo5I9fl9UjZAFGSzvlp
 sqlalchemy/testing/suite/test_cte.py,sha256=_GnADXRnhm37RdSRBR5SthQenTeb5VVo3HoCuO0Vifw,7262
 sqlalchemy/testing/suite/test_ddl.py,sha256=MItp-votCzvahlRqHRagte2Omyq9XUOFdFsgzCb6_-g,12031
 sqlalchemy/testing/suite/test_deprecations.py,sha256=7C6IbxRmq7wg_DLq56f1V5RCS9iVrAv3epJZQTB-dOo,5337
-sqlalchemy/testing/suite/test_dialect.py,sha256=87MWsFLqHzIHd-6Yn2Dz3fEr-KzsR9LNHfbcj-KRPVA,22908
+sqlalchemy/testing/suite/test_dialect.py,sha256=j3srr7k2aUd_kPtJPgqI1g1aYD6ko4MvuGu1a1HQgS8,24215
 sqlalchemy/testing/suite/test_insert.py,sha256=pR0VWMQ9JJPbnANE6634PzR0VFmWMF8im6OTahc4vsQ,18824
 sqlalchemy/testing/suite/test_reflection.py,sha256=oRqwm8ZUjDdXcE3mooIg5513FpNiwEl76IoJaa_aK-Q,114101
 sqlalchemy/testing/suite/test_results.py,sha256=S7Vqqh_Wuqf7uhM8h0cBVeV1GS5GJRO_ZTVYmT7kwuc,17042
@@ -262,8 +262,8 @@ sqlalchemy/util/queue.py,sha256=w1ufhuiC7lzyiZDhciRtRz1uyxU72jRI7SWhhL-p600,1018
 sqlalchemy/util/tool_support.py,sha256=e7lWu6o1QlKq4e6c9PyDsuyFyiWe79vO72UQ_YX2pUA,6135
 sqlalchemy/util/topological.py,sha256=tbkMRY0TTgNiq44NUJpnazXR4xb9v4Q4mQ8BygMp0vY,3451
 sqlalchemy/util/typing.py,sha256=iwyZIgOJUN2o9cRz8YTH093iY5iNvpXiDQG3pce0cc4,22466
-sqlalchemy-2.0.42.dist-info/licenses/LICENSE,sha256=mCFyC1jUpWW2EyEAeorUOraZGjlZ5mzV203Z6uacffw,1100
-sqlalchemy-2.0.42.dist-info/METADATA,sha256=lEWVC12ZcvgCCZM4H1suKUiHQYJhVOWVwGRrqDMycME,9577
-sqlalchemy-2.0.42.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlalchemy-2.0.42.dist-info/top_level.txt,sha256=rp-ZgB7D8G11ivXON5VGPjupT1voYmWqkciDt5Uaw_Q,11
-sqlalchemy-2.0.42.dist-info/RECORD,,
+sqlalchemy-2.0.43.dist-info/licenses/LICENSE,sha256=mCFyC1jUpWW2EyEAeorUOraZGjlZ5mzV203Z6uacffw,1100
+sqlalchemy-2.0.43.dist-info/METADATA,sha256=6StIsiY_vKcG9DPqObgaUSVms9cc12bYmm3KbXl9yMw,9577
+sqlalchemy-2.0.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlalchemy-2.0.43.dist-info/top_level.txt,sha256=rp-ZgB7D8G11ivXON5VGPjupT1voYmWqkciDt5Uaw_Q,11
+sqlalchemy-2.0.43.dist-info/RECORD,,