Add relaxed variants of the built-in SQLAlchemy PostgreSQL dialects

The corresponding dialect identifiers are:

- `postgresql+psycopg_relaxed`
- `postgresql+asyncpg_relaxed`

Author: amotl

pyproject.toml

@@ -85,6 +85,10 @@ changelog = "https://github.com/daq-tools/sqlalchemy-postgresql-relaxed/blob/mai
 documentation = "https://github.com/daq-tools/sqlalchemy-postgresql-relaxed"
 homepage = "https://github.com/daq-tools/sqlalchemy-postgresql-relaxed"
 repository = "https://github.com/daq-tools/sqlalchemy-postgresql-relaxed"
+[project.entry-points."sqlalchemy.dialects"]
+"postgresql.asyncpg_relaxed" = "sqlalchemy_postgresql_relaxed.asyncpg:dialect"
+"postgresql.psycopg_relaxed" = "sqlalchemy_postgresql_relaxed.psycopg:dialect"
+"postgresql.psycopg_relaxed_async" = "sqlalchemy_postgresql_relaxed.psycopg:dialect_async"
 
 [tool.setuptools.packages]
 find = {}

sqlalchemy_postgresql_relaxed/__init__.py

@@ -0,0 +1,23 @@
+from sqlalchemy.dialects.postgresql.asyncpg import PGDialect_asyncpg
+
+from sqlalchemy_postgresql_relaxed.base import PGDialect_relaxed
+
+
+class PGDialect_asyncpg_relaxed(PGDialect_relaxed, PGDialect_asyncpg):
+    """
+    Don't strictly expect JSON and JSONB codecs.
+
+    asyncpg.exceptions._base.InterfaceError: cannot use custom codec on non-scalar type pg_catalog.json
+    """
+
+    driver = "asyncpg_relaxed"
+    supports_statement_cache = True
+
+    async def setup_asyncpg_json_codec(self, conn):
+        pass
+
+    async def setup_asyncpg_jsonb_codec(self, conn):
+        pass
+
+
+dialect = PGDialect_asyncpg_relaxed

sqlalchemy_postgresql_relaxed/asyncpg.py

@@ -0,0 +1,50 @@
+import re
+
+from sqlalchemy.dialects.postgresql.base import PGDialect
+from sqlalchemy.engine.default import DefaultDialect
+
+
+class PGDialect_relaxed(PGDialect):
+    def _get_server_version_info(self, connection):
+        """
+        Accept non-conforming server version responses by adjusting signature matching pattern.
+
+        AssertionError: Could not determine version from string
+        'CrateDB 5.2.2 (built a33862e/2023-02-09T10:26:09Z, Linux 5.10.124-linuxkit amd64, OpenJDK 64-Bit Server VM 19.0.2+7)'
+        """  # noqa: E501
+        v = connection.exec_driver_sql("select pg_catalog.version()").scalar()
+        m = re.match(
+            r".*(?:PostgreSQL|EnterpriseDB|\w+?) " r"(\d+)\.?(\d+)?(?:\.(\d+))?(?:\.\d+)?(?:devel|beta)?",
+            v,
+        )
+        if not m:
+            raise AssertionError("Could not determine version from string '%s'" % v)
+        return tuple([int(x) for x in m.group(1, 2, 3) if x is not None])
+
+    def initialize(self, connection):
+        """
+        Don't issue `SHOW STANDARD_CONFORMING_STRINGS` inquiry.
+
+        sqlalchemy.exc.InternalError: (psycopg.errors.InternalError_)
+        Unknown session setting name 'standard_conforming_strings'.
+        """
+        DefaultDialect.initialize(self, connection)
+
+        # https://www.postgresql.org/docs/9.3/static/release-9-2.html#AEN116689
+        self.supports_smallserial = self.server_version_info >= (9, 2)
+
+        # PATCH. Let's assume "on"?
+        """
+        std_string = connection.exec_driver_sql(
+            "show standard_conforming_strings"
+        ).scalar()
+        """
+        std_string = "on"
+
+        self._backslash_escapes = std_string == "off"
+
+        self._supports_drop_index_concurrently = self.server_version_info >= (
+            9,
+            2,
+        )
+        self.supports_identity_columns = self.server_version_info >= (10,)

sqlalchemy_postgresql_relaxed/base.py

@@ -0,0 +1,21 @@
+from sqlalchemy.dialects.postgresql.psycopg import PGDialect_psycopg, PGDialectAsync_psycopg
+
+from sqlalchemy_postgresql_relaxed.base import PGDialect_relaxed
+
+
+class PGDialect_psycopg_relaxed(PGDialect_relaxed, PGDialect_psycopg):
+    driver = "psycopg_relaxed"
+
+    @classmethod
+    def get_async_dialect_cls(cls, url):
+        return PGDialectAsync_psycopg_relaxed
+
+
+class PGDialectAsync_psycopg_relaxed(PGDialect_psycopg_relaxed, PGDialectAsync_psycopg):
+    is_async = True
+    supports_statement_cache = True
+    driver = "psycopg_async_relaxed"
+
+
+dialect = PGDialect_psycopg_relaxed
+dialect_async = PGDialectAsync_psycopg_relaxed

sqlalchemy_postgresql_relaxed/psycopg.py

@@ -0,0 +1,49 @@
+import pytest
+import sqlalchemy as sa
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+
+def test_psycopg_sync():
+    engine = sa.create_engine(
+        url="postgresql+psycopg_relaxed://crate@localhost/acme",
+        isolation_level="AUTOCOMMIT",
+        use_native_hstore=False,
+        echo=True,
+    )
+    with engine.connect() as con:
+        result = con.exec_driver_sql("SELECT 'Kill all humans.';")
+        assert result.scalar_one() == "Kill all humans."
+    con.close()
+
+
+@pytest.mark.asyncio
+async def test_psycopg_async():
+    engine = create_async_engine(
+        url="postgresql+psycopg_relaxed://crate@localhost/acme",
+        isolation_level="AUTOCOMMIT",
+        use_native_hstore=False,
+        echo=True,
+    )
+    async_session = async_sessionmaker(engine)
+    session: AsyncSession
+    async with async_session() as session:
+        result = await session.execute(sa.text("SELECT 'Kill all humans.';"))
+        assert result.scalar_one() == "Kill all humans."
+    await session.close()
+    await engine.dispose()
+
+
+@pytest.mark.asyncio
+async def test_asyncpg():
+    engine = create_async_engine(
+        url="postgresql+asyncpg_relaxed://crate@localhost/acme",
+        isolation_level="AUTOCOMMIT",
+        echo=True,
+    )
+    async_session = async_sessionmaker(engine)
+    session: AsyncSession
+    async with async_session() as session:
+        result = await session.execute(sa.text("SELECT 'Kill all humans.';"))
+        assert result.scalar_one() == "Kill all humans."
+    await session.close()
+    await engine.dispose()