SQLAlchemy 2.0.49__py3-none-any.whl → 2.0.51__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.49"
+__version__ = "2.0.51"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/connectors/aioodbc.py

@@ -20,7 +20,6 @@ from .. import util
 from ..util.concurrency import await_fallback
 from ..util.concurrency import await_only
 
-
 if TYPE_CHECKING:
     from ..engine.interfaces import ConnectArgsType
     from ..engine.url import URL

sqlalchemy/dialects/_typing.py

@@ -18,7 +18,6 @@ from ..sql.schema import Column
 from ..sql.schema import ColumnCollectionConstraint
 from ..sql.schema import Index
 
-
 _OnConflictConstraintT = Union[str, ColumnCollectionConstraint, Index, None]
 _OnConflictIndexElementsT = Optional[
     Iterable[Union[Column[Any], str, roles.DDLConstraintColumnRole]]

sqlalchemy/dialects/mssql/__init__.py

@@ -45,7 +45,6 @@ from .base import VARCHAR
 from .base import XML
 from ...sql import try_cast
 
-
 base.dialect = dialect = pyodbc.dialect
 
 

sqlalchemy/dialects/mssql/base.py

@@ -3220,8 +3220,7 @@ class MSDialect(default.DefaultDialect):
 
             view_name = f"sys.{row[0]}"
 
-            cursor.execute(
-                """
+            cursor.execute("""
                     SELECT CASE transaction_isolation_level
                     WHEN 0 THEN NULL
                     WHEN 1 THEN 'READ UNCOMMITTED'
@@ -3232,10 +3231,7 @@ class MSDialect(default.DefaultDialect):
                     AS TRANSACTION_ISOLATION_LEVEL
                     FROM {}
                     where session_id = @@SPID
-                """.format(
-                    view_name
-                )
-            )
+                """.format(view_name))
         except self.dbapi.Error as err:
             raise NotImplementedError(
                 "Can't fetch isolation level;  encountered error {} when "
@@ -3432,8 +3428,7 @@ class MSDialect(default.DefaultDialect):
             else "NULL as filter_definition"
         )
         rp = connection.execution_options(future_result=True).execute(
-            sql.text(
-                f"""
+            sql.text(f"""
 select
     ind.index_id,
     ind.is_unique,
@@ -3453,8 +3448,7 @@ where
     and ind.type != 0
 order by
     ind.name
-                """
-            )
+                """)
             .bindparams(
                 sql.bindparam("tabname", tablename, ischema.CoerceUnicode()),
                 sql.bindparam("schname", owner, ischema.CoerceUnicode()),
@@ -3482,8 +3476,7 @@ order by
                 do["mssql_where"] = row["filter_definition"]
 
         rp = connection.execution_options(future_result=True).execute(
-            sql.text(
-                """
+            sql.text("""
 select
     ind_col.index_id,
     col.name,
@@ -3503,8 +3496,7 @@ where
 order by
     ind_col.index_id,
     ind_col.key_ordinal
-            """
-            )
+            """)
             .bindparams(
                 sql.bindparam("tabname", tablename, ischema.CoerceUnicode()),
                 sql.bindparam("schname", owner, ischema.CoerceUnicode()),
@@ -3930,8 +3922,7 @@ order by
     ):
         # Foreign key constraints
         s = (
-            text(
-                """\
+            text("""\
 WITH fk_info AS (
     SELECT
         ischema_ref_con.constraint_schema,
@@ -4031,8 +4022,7 @@ index_info AS (
 
     ORDER BY fk_info.constraint_schema, fk_info.constraint_name,
         fk_info.ordinal_position
-"""
-            )
+""")
             .bindparams(
                 sql.bindparam("tablename", tablename, ischema.CoerceUnicode()),
                 sql.bindparam("owner", owner, ischema.CoerceUnicode()),

sqlalchemy/dialects/mssql/information_schema.py

@@ -20,7 +20,6 @@ from ...types import String
 from ...types import TypeDecorator
 from ...types import Unicode
 
-
 ischema = MetaData()
 
 

sqlalchemy/dialects/mssql/pymssql.py

@@ -22,6 +22,7 @@ pymssql is a Python module that provides a Python DBAPI interface around
 
 
 """  # noqa
+
 import re
 
 from .base import MSDialect

sqlalchemy/dialects/mssql/pyodbc.py

@@ -359,7 +359,6 @@ hook. See that method for usage examples.
 
 """  # noqa
 
-
 import datetime
 import decimal
 import re

sqlalchemy/dialects/mysql/aiomysql.py

@@ -28,6 +28,7 @@ This dialect should normally be used only with the
     )
 
 """  # noqa
+
 from __future__ import annotations
 
 from types import ModuleType
@@ -38,6 +39,7 @@ from typing import Tuple
 from typing import TYPE_CHECKING
 from typing import Union
 
+from .pymysql import _connection_ping_reconnects_true
 from .pymysql import MySQLDialect_pymysql
 from ... import pool
 from ... import util
@@ -46,6 +48,7 @@ from ...connectors.asyncio import AsyncAdapt_dbapi_cursor
 from ...connectors.asyncio import AsyncAdapt_dbapi_module
 from ...connectors.asyncio import AsyncAdapt_dbapi_ss_cursor
 from ...connectors.asyncio import AsyncAdapt_terminate
+from ...util import langhelpers
 from ...util.concurrency import await_fallback
 from ...util.concurrency import await_only
 
@@ -91,9 +94,12 @@ class AsyncAdapt_aiomysql_connection(
     _cursor_cls = AsyncAdapt_aiomysql_cursor
     _ss_cursor_cls = AsyncAdapt_aiomysql_ss_cursor
 
-    def ping(self, reconnect: bool) -> None:
+    def ping(self, reconnect: bool = False) -> None:
         assert not reconnect
-        self.await_(self._connection.ping(reconnect))
+        if self.dbapi._send_false_to_ping:
+            self.await_(self._connection.ping(reconnect=False))
+        else:
+            self.await_(self._connection.ping())
 
     def character_set_name(self) -> Optional[str]:
         return self._connection.character_set_name()  # type: ignore[no-any-return]  # noqa: E501
@@ -170,6 +176,24 @@ class AsyncAdapt_aiomysql_dbapi(AsyncAdapt_dbapi_module):
                 await_only(creator_fn(*arg, **kw)),
             )
 
+    @langhelpers.memoized_property
+    def _send_false_to_ping(self) -> bool:
+        """determine if aiomysql has deprecated, changed the default of,
+        or removed the 'reconnect' argument of connection.ping().
+
+        See #13306 and #10492
+
+        """  # noqa: E501
+
+        try:
+            Connection = __import__(
+                "aiomysql.connection"
+            ).connection.Connection
+        except (ImportError, AttributeError):
+            return True
+        else:
+            return _connection_ping_reconnects_true(Connection)
+
     def _init_cursors_subclasses(
         self,
     ) -> Tuple[AsyncIODBAPICursor, AsyncIODBAPICursor]:

sqlalchemy/dialects/mysql/asyncmy.py

@@ -26,6 +26,7 @@ This dialect should normally be used only with the
     )
 
 """  # noqa
+
 from __future__ import annotations
 
 from types import ModuleType
@@ -35,6 +36,7 @@ from typing import Optional
 from typing import TYPE_CHECKING
 from typing import Union
 
+from .pymysql import _connection_ping_reconnects_true
 from .pymysql import MySQLDialect_pymysql
 from ... import pool
 from ... import util
@@ -43,6 +45,7 @@ from ...connectors.asyncio import AsyncAdapt_dbapi_cursor
 from ...connectors.asyncio import AsyncAdapt_dbapi_module
 from ...connectors.asyncio import AsyncAdapt_dbapi_ss_cursor
 from ...connectors.asyncio import AsyncAdapt_terminate
+from ...util import langhelpers
 from ...util.concurrency import await_fallback
 from ...util.concurrency import await_only
 
@@ -86,18 +89,21 @@ class AsyncAdapt_asyncmy_connection(
         if isinstance(error, AttributeError):
             raise self.dbapi.InternalError(
                 "network operation failed due to asyncmy attribute error"
-            )
+            ) from error
 
         raise error
 
-    def ping(self, reconnect: bool) -> None:
+    def ping(self, reconnect: bool = False) -> None:
         assert not reconnect
         return self.await_(self._do_ping())
 
     async def _do_ping(self) -> None:
         try:
             async with self._execute_mutex:
-                await self._connection.ping(False)
+                if self.dbapi._send_false_to_ping:
+                    await self._connection.ping(reconnect=False)
+                else:
+                    await self._connection.ping()
         except Exception as error:
             self._handle_exception(error)
 
@@ -171,6 +177,22 @@ class AsyncAdapt_asyncmy_dbapi(AsyncAdapt_dbapi_module):
                 await_only(creator_fn(*arg, **kw)),
             )
 
+    @langhelpers.memoized_property
+    def _send_false_to_ping(self) -> bool:
+        """determine if asyncmy has deprecated, changed the default of,
+        or removed the 'reconnect' argument of connection.ping().
+
+        See #13306 and #10492
+
+        """  # noqa: E501
+
+        try:
+            Connection = __import__("asyncmy.connection").connection.Connection
+        except (ImportError, AttributeError):
+            return True
+        else:
+            return _connection_ping_reconnects_true(Connection)
+
 
 class MySQLDialect_asyncmy(MySQLDialect_pymysql):
     driver = "asyncmy"

sqlalchemy/dialects/mysql/base.py

@@ -1063,6 +1063,7 @@ output:
     )
 
 """  # noqa
+
 from __future__ import annotations
 
 from collections import defaultdict
@@ -2764,6 +2765,7 @@ class MySQLDialect(default.DefaultDialect):
     # i.e. first connect
     _backslash_escapes = True
     _server_ansiquotes = False
+    _casing = 0
 
     server_version_info: Tuple[int, ...]
     identifier_preparer: MySQLIdentifierPreparer
@@ -3186,9 +3188,9 @@ class MySQLDialect(default.DefaultDialect):
             self._is_mysql and self.server_version_info >= (8, 0, 1)
         )
 
-        self._needs_correct_for_88718_96365 = (
-            not self.is_mariadb and self.server_version_info >= (8,)
-        )
+        self._needs_correct_for_88718_96365 = self.server_version_info >= (
+            8,
+        ) and (self.server_version_info < (8, 0, 14) or self._casing == 2)
 
         self.delete_returning = (
             self.is_mariadb and self.server_version_info >= (10, 0, 5)
@@ -3253,7 +3255,7 @@ class MySQLDialect(default.DefaultDialect):
     def _is_mariadb_102(self) -> bool:
         return (
             self.is_mariadb
-            and self._mariadb_normalized_version_info  # type:ignore[operator]
+            and self._mariadb_normalized_version_info  # type: ignore[operator]
             > (
                 10,
                 2,

sqlalchemy/dialects/mysql/cymysql.py

@@ -20,6 +20,7 @@ r"""
     dialects are mysqlclient and PyMySQL.
 
 """  # noqa
+
 from __future__ import annotations
 
 from typing import Any

sqlalchemy/dialects/mysql/dml.py

@@ -28,7 +28,6 @@ from ...sql.expression import alias
 from ...sql.selectable import NamedFromClause
 from ...util.typing import Self
 
-
 __all__ = ("Insert", "insert")
 
 

sqlalchemy/dialects/mysql/mariadbconnector.py

@@ -27,6 +27,7 @@ be ``mysqldb``. ``mariadb+mariadbconnector://`` is required to use this driver.
 .. mariadb: https://github.com/mariadb-corporation/mariadb-connector-python
 
 """  # noqa
+
 from __future__ import annotations
 
 import re

sqlalchemy/dialects/mysql/mysqlconnector.py

@@ -45,6 +45,7 @@ charset/collation will allow connectivity.
 
 
 """  # noqa
+
 from __future__ import annotations
 
 import re
@@ -110,8 +111,8 @@ class IdentifierPreparerCommon_mysqlconnector:
 
     def _escape_identifier(self, value: str) -> str:
         value = value.replace(
-            self.escape_quote,  # type:ignore[attr-defined]
-            self.escape_to_quote,  # type:ignore[attr-defined]
+            self.escape_quote,  # type: ignore[attr-defined]
+            self.escape_to_quote,  # type: ignore[attr-defined]
         )
         return value
 

sqlalchemy/dialects/mysql/mysqldb.py

@@ -84,6 +84,7 @@ Server Side Cursors
 The mysqldb dialect supports server-side cursors. See :ref:`mysql_ss_cursors`.
 
 """
+
 from __future__ import annotations
 
 import re

sqlalchemy/dialects/mysql/pymysql.py

@@ -47,11 +47,13 @@ and targets 100% compatibility.   Most behavioral notes for MySQL-python apply
 to the pymysql driver as well.
 
 """  # noqa
+
 from __future__ import annotations
 
 from typing import Any
 from typing import Dict
 from typing import Optional
+from typing import Type
 from typing import TYPE_CHECKING
 from typing import Union
 
@@ -69,6 +71,31 @@ if TYPE_CHECKING:
     from ...engine.url import URL
 
 
+def _connection_ping_reconnects_true(connection_cls: Type[Any]) -> bool:
+    """Given a Connection class like pymysql.Connection, aiomysql.Connection,
+    asyncmy.Connection, inspect the ping() method and determine if it
+    has a "reconnect" parameter that either defaults to True, or is positional.
+
+    a return value of True here means that when we call ``connection.ping()``,
+    we **must** pass `reconnect=False`.  a return value of False means that
+    we should call ``connection.ping()`` with **no arguments**.
+
+    This routine originates from issue #10492 for pymysql, however arg
+    signature mismatches in aiomysql/asyncmy tracked by issue #13306
+    necessitated a more open ended function.
+
+    """
+    insp = langhelpers.get_callable_argspec(connection_cls.ping)
+    try:
+        reconnect_arg = insp.args[1]
+    except IndexError:
+        return False
+    else:
+        return reconnect_arg == "reconnect" and (
+            not insp.defaults or insp.defaults[0] is not False
+        )
+
+
 class MySQLDialect_pymysql(MySQLDialect_mysqldb):
     driver = "pymysql"
     supports_statement_cache = True
@@ -97,6 +124,8 @@ class MySQLDialect_pymysql(MySQLDialect_mysqldb):
         https://github.com/PyMySQL/mysqlclient/discussions/651#discussioncomment-7308971
         for background.
 
+        Revised as part of #13306
+
         """  # noqa: E501
 
         try:
@@ -106,15 +135,7 @@ class MySQLDialect_pymysql(MySQLDialect_mysqldb):
         except (ImportError, AttributeError):
             return True
         else:
-            insp = langhelpers.get_callable_argspec(Connection.ping)
-            try:
-                reconnect_arg = insp.args[1]
-            except IndexError:
-                return False
-            else:
-                return reconnect_arg == "reconnect" and (
-                    not insp.defaults or insp.defaults[0] is not False
-                )
+            return _connection_ping_reconnects_true(Connection)
 
     def do_ping(self, dbapi_connection: DBAPIConnection) -> Literal[True]:
         if self._send_false_to_ping:

sqlalchemy/dialects/mysql/pyodbc.py

@@ -42,6 +42,7 @@ Pass through exact pyodbc connection string::
     connection_uri = "mysql+pyodbc:///?odbc_connect=%s" % params
 
 """  # noqa
+
 from __future__ import annotations
 
 import datetime

sqlalchemy/dialects/mysql/reflection.py

@@ -371,7 +371,7 @@ class MySQLTableDefinitionParser:
 
         buffer = []
         for row in columns:
-            (name, col_type, nullable, default, extra) = (
+            name, col_type, nullable, default, extra = (
                 row[i] for i in (0, 1, 2, 4, 5)
             )
 
@@ -704,7 +704,7 @@ def cleanup_text(raw_text: str) -> str:
     if "\\" in raw_text:
         raw_text = re.sub(
             _control_char_regexp,
-            lambda s: _control_char_map[s[0]],  # type: ignore[index]
+            lambda s: _control_char_map[s[0]],  # type: ignore[unused-ignore,index]  # noqa: E501
             raw_text,
         )
     return raw_text.replace("''", "'")

sqlalchemy/dialects/oracle/cx_oracle.py

@@ -489,6 +489,7 @@ SQLAlchemy type (or a subclass of such).
    as better integration of outputtypehandlers.
 
 """  # noqa
+
 from __future__ import annotations
 
 import decimal

sqlalchemy/dialects/oracle/oracledb.py

@@ -588,6 +588,7 @@ SQLAlchemy type (or a subclass of such).
 .. versionadded:: 2.0.0 added support for the python-oracledb driver.
 
 """  # noqa
+
 from __future__ import annotations
 
 import collections

sqlalchemy/dialects/oracle/vector.py

@@ -313,12 +313,10 @@ class VECTOR(types.TypeEngine):
                 )
 
             else:
-                raise TypeError(
-                    """
+                raise TypeError("""
                     Invalid input for VECTOR: expected a list, an array.array,
                     or a SparseVector object.
-                    """
-                )
+                    """)
 
         return process
 

sqlalchemy/dialects/postgresql/__init__.py

@@ -89,7 +89,6 @@ from .types import TIMESTAMP
 from .types import TSQUERY
 from .types import TSVECTOR
 
-
 # Alias psycopg also as psycopg_async
 psycopg_async = type(
     "psycopg_async", (ModuleType,), {"dialect": psycopg.dialect_async}

sqlalchemy/dialects/postgresql/_psycopg_common.py

@@ -187,3 +187,39 @@ class _PGDialect_common_psycopg(PGDialect):
                 dbapi_connection.autocommit = before_autocommit
 
         return True
+
+    def do_begin_twophase(self, connection, xid):
+        connection.connection.tpc_begin(xid)
+
+    def do_prepare_twophase(self, connection, xid):
+        connection.connection.tpc_prepare()
+
+    def _do_twophase(self, dbapi_conn, operation, xid, recover=False):
+        if recover:
+            if not self._twophase_idle_check(dbapi_conn):
+                dbapi_conn.rollback()
+            operation(xid)
+        else:
+            operation()
+
+    def _twophase_idle_check(self, dbapi_conn):
+        raise NotImplementedError
+
+    def do_rollback_twophase(
+        self, connection, xid, is_prepared=True, recover=False
+    ):
+        dbapi_conn = connection.connection.dbapi_connection
+        self._do_twophase(
+            dbapi_conn, dbapi_conn.tpc_rollback, xid, recover=recover
+        )
+
+    def do_commit_twophase(
+        self, connection, xid, is_prepared=True, recover=False
+    ):
+        dbapi_conn = connection.connection.dbapi_connection
+        self._do_twophase(
+            dbapi_conn, dbapi_conn.tpc_commit, xid, recover=recover
+        )
+
+    def do_recover_twophase(self, connection):
+        return [str(row) for row in connection.connection.tpc_recover()]

sqlalchemy/dialects/postgresql/asyncpg.py

@@ -990,6 +990,9 @@ class AsyncAdapt_asyncpg_dbapi:
     class InternalServerError(InternalError):
         pass
 
+    class InternalClientError(InternalError):
+        pass
+
     class InvalidCachedStatementError(NotSupportedError):
         def __init__(self, message):
             super().__init__(
@@ -1014,6 +1017,7 @@ class AsyncAdapt_asyncpg_dbapi:
             asyncpg.exceptions.InterfaceError: self.InterfaceError,
             asyncpg.exceptions.InvalidCachedStatementError: self.InvalidCachedStatementError,  # noqa: E501
             asyncpg.exceptions.InternalServerError: self.InternalServerError,
+            asyncpg.exceptions.InternalClientError: self.InternalClientError,
         }
 
     def Binary(self, value):
@@ -1212,7 +1216,6 @@ class PGDialect_asyncpg(PGDialect):
         """
 
         asyncpg_connection = conn._connection
-        deserializer = self._json_deserializer or _py_json.loads
 
         def _jsonb_encoder(str_value):
             # \x01 is the prefix for jsonb used by PostgreSQL.

sqlalchemy/dialects/postgresql/base.py

@@ -1198,6 +1198,21 @@ constraints, enabling table inheritance hierarchies in PostgreSQL.
 
     Table("some_table", metadata, ..., postgresql_inherits=("t1", "t2", ...))
 
+For schema-qualified parent table names, use :class:`.quoted_name` with
+``quote=False`` to prevent the dotted name from being quoted as a single
+identifier::
+
+    from sqlalchemy.sql import quoted_name
+
+    Table(
+        "some_table",
+        metadata,
+        ...,
+        postgresql_inherits=quoted_name(
+            "my_schema.some_supertable", quote=False
+        ),
+    )
+
 ``ON COMMIT``
 ^^^^^^^^^^^^^
 
@@ -1390,6 +1405,29 @@ that are subject to the action::
 .. versionadded:: 2.0.40
 
 
+``NULLS NOT DISTINCT``
+^^^^^^^^^^^^^^^^^^^^^^
+
+By default, two ``null`` values are not considered equal for unique constraints
+and indexes. Therefore, seemingly duplicate rows may be stored if one of the
+values in the constraint is ``null``. This default behavior is implementation
+defined, so other SQL dialects may behave differently than PostgreSQL.
+
+The ``NULLS NOT DISTINCT`` clause can be used to change this behavior, treating
+null values as equal and preventing unintended duplicate rows. The opposite
+``NULLS DISTINCT`` clause can also be used to make PostgreSQL's default behavior
+explict.
+
+The ``postgresql_nulls_not_distinct`` parameter can be set to ``True`` to
+add the ``NULLS NOT DISTINCT`` clause, or ``False`` to add ``NULLS DISTINCT``.
+Not setting it, or passing ``None``, will not add a clause and keep the default
+behavior.
+
+This feature requires PostgreSQL 15 or later.
+
+.. versionadded:: 2.0.16
+
+
 .. _postgresql_table_valued_overview:
 
 Table values, Table and Column valued functions, Row and Tuple objects
@@ -3478,7 +3516,11 @@ class PGDialect(default.DefaultDialect):
         self.do_begin(connection.connection)
 
     def do_prepare_twophase(self, connection, xid):
-        connection.exec_driver_sql("PREPARE TRANSACTION '%s'" % xid)
+        connection.execute(
+            sql.text("PREPARE TRANSACTION :xid").bindparams(
+                sql.bindparam("xid", xid, literal_execute=True)
+            )
+        )
 
     def do_rollback_twophase(
         self, connection, xid, is_prepared=True, recover=False
@@ -3490,7 +3532,11 @@ class PGDialect(default.DefaultDialect):
                 # Must find out a way how to make the dbapi not
                 # open a transaction.
                 connection.exec_driver_sql("ROLLBACK")
-            connection.exec_driver_sql("ROLLBACK PREPARED '%s'" % xid)
+            connection.execute(
+                sql.text("ROLLBACK PREPARED :xid").bindparams(
+                    sql.bindparam("xid", xid, literal_execute=True)
+                )
+            )
             connection.exec_driver_sql("BEGIN")
             self.do_rollback(connection.connection)
         else:
@@ -3502,7 +3548,11 @@ class PGDialect(default.DefaultDialect):
         if is_prepared:
             if recover:
                 connection.exec_driver_sql("ROLLBACK")
-            connection.exec_driver_sql("COMMIT PREPARED '%s'" % xid)
+            connection.execute(
+                sql.text("COMMIT PREPARED :xid").bindparams(
+                    sql.bindparam("xid", xid, literal_execute=True)
+                )
+            )
             connection.exec_driver_sql("BEGIN")
             self.do_rollback(connection.connection)
         else: