sqlalchemy-firebird-async 0.2.0__tar.gz → 0.2.2__tar.gz

sqlalchemy_firebird_async-0.2.2/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(TEST_DIALECT=firebird_async uv run pytest:*)",
+      "Bash(TEST_DIALECT=firebird_sync uv run pytest:*)",
+      "Bash(grep:*)"
+    ]
+  }
+}

{sqlalchemy_firebird_async-0.2.0 → sqlalchemy_firebird_async-0.2.2}/.gitignore

@@ -148,3 +148,4 @@ cython_debug/
 # PyCharm
 .idea/
 uv.lock
+setup.cfg

sqlalchemy_firebird_async-0.2.2/CONTRIBUTING.md

@@ -0,0 +1,58 @@
+# Contributing to sqlalchemy-firebird-async
+
+First off, thanks for taking the time to contribute!
+
+## Development Setup
+
+1. **Clone the repository:**
+   ```bash
+   git clone https://github.com/attid/sqlalchemy-firebird-async.git
+   cd sqlalchemy-firebird-async
+   ```
+
+2. **Install dependencies (using `uv` or `pip`):**
+   ```bash
+   uv sync  # or pip install -e .[all,test]
+   ```
+
+## Running Tests
+
+We use `pytest` and `testcontainers` (Docker) for testing. Ensure Docker is running.
+
+### 1. Standard Tests (Recommended)
+These tests cover the core functionality of the asynchronous drivers (Core, ORM, Types).
+
+```bash
+# Run tests for the default driver (fdb_async)
+uv run pytest
+
+# Run tests for the new driver (firebird_async)
+TEST_DIALECT=firebird_async uv run pytest
+```
+
+### 2. SQLAlchemy Compliance Suite (Advanced)
+These tests run the official SQLAlchemy test suite against our dialect. This is useful for verifying deep compatibility.
+
+**Note:** This automatically starts a Firebird container and configures `setup.cfg`.
+
+```bash
+# Run Compliance Suite using fdb_async
+TEST_DIALECT=firebird_async uv run pytest tests/test_compliance.py -p sqlalchemy.testing.plugin.pytestplugin
+```
+
+## Supported Drivers
+
+*   **`fdb_async`** (Default): Uses the threaded legacy `fdb` driver. Stable but lacks some FB4 features.
+*   **`firebird_async`**: Uses the modern `firebird-driver`. Supports FB4 features (INT128, TimeZones).
+
+## Project Structure
+
+*   `src/sqlalchemy_firebird_async/`: Source code.
+    *   `fdb.py`: `fdb` based dialect.
+    *   `firebird_driver.py`: `firebird-driver` based dialect.
+    *   `compiler.py`: Custom type compiler patches.
+*   `tests/`: Tests.
+    *   `test_basic.py`: Basic CRUD and ORM tests.
+    *   `test_types.py`: Comprehensive data types tests.
+    *   `test_load.py`: Concurrency load test.
+    *   `test_compliance.py`: Entry point for SQLAlchemy Compliance Suite.

{sqlalchemy_firebird_async-0.2.0 → sqlalchemy_firebird_async-0.2.2}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-firebird-async
-Version: 0.2.0
+Version: 0.2.2
 Summary: Asyncio support for Firebird in SQLAlchemy
 Project-URL: Homepage, https://github.com/attid/sqlalchemy-firebird-async
+Project-URL: Repository, https://github.com/attid/sqlalchemy-firebird-async
+Project-URL: Issues, https://github.com/attid/sqlalchemy-firebird-async/issues
 Author-email: Igor Tolstov <attid0@gmail.com>
 License: MIT
 License-File: LICENSE
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -32,9 +34,12 @@ Description-Content-Type: text/markdown
 
 # sqlalchemy-firebird-async
 
-![Python Version](https://img.shields.io/pypi/pyversions/sqlalchemy-firebird-async)
-![License](https://img.shields.io/pypi/l/sqlalchemy-firebird-async)
-![Status](https://img.shields.io/pypi/status/sqlalchemy-firebird-async)
+[![Python Version](https://img.shields.io/pypi/pyversions/sqlalchemy-firebird-async?style=for-the-badge)](https://pypi.org/project/sqlalchemy-firebird-async/)
+[![License](https://img.shields.io/pypi/l/sqlalchemy-firebird-async?style=for-the-badge)](https://pypi.org/project/sqlalchemy-firebird-async/)
+[![Status](https://img.shields.io/pypi/status/sqlalchemy-firebird-async?style=for-the-badge)](https://pypi.org/project/sqlalchemy-firebird-async/)
+[![PyPI](https://img.shields.io/pypi/v/sqlalchemy-firebird-async?style=for-the-badge)](https://pypi.org/project/sqlalchemy-firebird-async/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/sqlalchemy-firebird-async?style=for-the-badge)](https://pypistats.org/packages/sqlalchemy-firebird-async)
+
 
 **Asynchronous Firebird dialect for SQLAlchemy.**
 

{sqlalchemy_firebird_async-0.2.0 → sqlalchemy_firebird_async-0.2.2}/README.md

@@ -1,8 +1,11 @@
 # sqlalchemy-firebird-async
 
-![Python Version](https://img.shields.io/pypi/pyversions/sqlalchemy-firebird-async)
-![License](https://img.shields.io/pypi/l/sqlalchemy-firebird-async)
-![Status](https://img.shields.io/pypi/status/sqlalchemy-firebird-async)
+[![Python Version](https://img.shields.io/pypi/pyversions/sqlalchemy-firebird-async?style=for-the-badge)](https://pypi.org/project/sqlalchemy-firebird-async/)
+[![License](https://img.shields.io/pypi/l/sqlalchemy-firebird-async?style=for-the-badge)](https://pypi.org/project/sqlalchemy-firebird-async/)
+[![Status](https://img.shields.io/pypi/status/sqlalchemy-firebird-async?style=for-the-badge)](https://pypi.org/project/sqlalchemy-firebird-async/)
+[![PyPI](https://img.shields.io/pypi/v/sqlalchemy-firebird-async?style=for-the-badge)](https://pypi.org/project/sqlalchemy-firebird-async/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/sqlalchemy-firebird-async?style=for-the-badge)](https://pypistats.org/packages/sqlalchemy-firebird-async)
+
 
 **Asynchronous Firebird dialect for SQLAlchemy.**
 

sqlalchemy_firebird_async-0.2.2/justfile

@@ -0,0 +1,11 @@
+
+
+test: 
+  uv run pytest
+
+build:
+  uv build
+
+publish:
+  export UV_PUBLISH_TOKEN=$(grep -A 5 "\[pypi\]" ~/.pypirc | grep "password" | cut -d = -f 2 | tr -d ' ')
+  uv publish

{sqlalchemy_firebird_async-0.2.0 → sqlalchemy_firebird_async-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlalchemy-firebird-async"
-version = "0.2.0"
+version = "0.2.2"
 description = "Asyncio support for Firebird in SQLAlchemy"
 readme = "README.md"
 authors = [
@@ -12,7 +12,7 @@ authors = [
 ]
 license = { text = "MIT" }
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "Programming Language :: Python :: 3",
     "Framework :: AsyncIO",
@@ -42,3 +42,5 @@ test = [
 
 [project.urls]
 "Homepage" = "https://github.com/attid/sqlalchemy-firebird-async"
+"Repository" = "https://github.com/attid/sqlalchemy-firebird-async"
+"Issues" = "https://github.com/attid/sqlalchemy-firebird-async/issues"

sqlalchemy_firebird_async-0.2.2/pytest.ini

@@ -0,0 +1,5 @@
+[pytest]
+addopts = --tb=native -v -r s
+testpaths = tests
+# Plugin for testing dialects
+# Usually this is 'sqlalchemy.testing.plugin.pytestplugin'

sqlalchemy_firebird_async-0.2.2/repro_cast.py

@@ -0,0 +1,25 @@
+import firebird.driver as driver
+import os
+
+user = os.environ.get("ISC_USER", "sysdba")
+password = os.environ.get("ISC_PASSWORD", "masterkey")
+host = os.environ.get("ISC_HOST", "localhost")
+database = os.environ.get("ISC_DATABASE", "/tmp/test.fdb")
+
+dsn = f"{host}:{database}"
+
+print(f"Connecting to {dsn} with user {user}...")
+
+try:
+    con = driver.connect(dsn, user=user, password=password)
+    cur = con.cursor()
+    
+    # Test CAST with TIMESTAMP(6)
+    sql = "SELECT CAST('2023-01-01 10:00:00' AS TIMESTAMP(6)) FROM RDB$DATABASE"
+    print(f"Executing: {sql}")
+    cur.execute(sql)
+    print("Success!")
+    
+    con.close()
+except Exception as e:
+    print(f"Failed: {e}")

sqlalchemy_firebird_async-0.2.2/src/sqlalchemy_firebird_async/compiler.py

@@ -0,0 +1,166 @@
+from sqlalchemy_firebird.base import FBCompiler
+from sqlalchemy_firebird.base import FBTypeCompiler
+from sqlalchemy_firebird.base import FBDDLCompiler
+from sqlalchemy.sql import elements
+from sqlalchemy.sql import expression
+from sqlalchemy.sql import operators
+from sqlalchemy.sql.compiler import OPERATORS
+
+class PatchedFBDDLCompiler(FBDDLCompiler):
+    def visit_unique_constraint(self, constraint, **kw):
+        # Firebird can be picky about quoted constraint names with spaces in some contexts
+        # but SQLAlchemy testing uses them.
+        return super().visit_unique_constraint(constraint, **kw)
+
+class PatchedFBTypeCompiler(FBTypeCompiler):
+    def _render_string_type(self, type_, name=None, length_override=None, **kwargs):
+        if name is None and isinstance(type_, str):
+            name = type_
+            type_ = None
+
+        if length_override is None and "length" in kwargs:
+            length_override = kwargs.pop("length")
+
+        collation = kwargs.pop("collation", None)
+
+        if type_ is None:
+            text = name
+            if length_override:
+                text += f"({length_override})"
+            if collation:
+                text += f" COLLATE {collation}"
+            return text
+
+        # Fix for TypeError: unsupported operand type(s) for +: 'int' and 'str'
+        if not isinstance(name, str):
+            # Attempt to restore type name from the type object itself
+            if hasattr(type_, "__visit_name__"):
+                name = type_.__visit_name__.upper()
+            else:
+                name = "VARCHAR"
+        return super()._render_string_type(type_, name, length_override)
+
+    def visit_VARCHAR(self, type_, **kw):
+        return self._render_string_type(type_, "VARCHAR", length_override=type_.length)
+
+    def visit_CHAR(self, type_, **kw):
+        return self._render_string_type(type_, "CHAR", length_override=type_.length)
+
+    def visit_NVARCHAR(self, type_, **kw):
+        return self._render_string_type(type_, "NVARCHAR", length_override=type_.length)
+
+    def visit_NCHAR(self, type_, **kw):
+        return self._render_string_type(type_, "NCHAR", length_override=type_.length)
+
+    def visit_DOUBLE(self, type_, **kw):
+        return "DOUBLE PRECISION"
+
+    def visit_DOUBLE_PRECISION(self, type_, **kw):
+        return "DOUBLE PRECISION"
+
+    def visit_FLOAT(self, type_, **kw):
+        return "DOUBLE PRECISION"
+
+    def visit_TIMESTAMP(self, type_, **kw):
+        return "TIMESTAMP"
+
+    def visit_TIME(self, type_, **kw):
+        return "TIME"
+
+    def visit_datetime(self, type_, **kw):
+        return "TIMESTAMP"
+
+
+import re
+
+class PatchedFBCompiler(FBCompiler):
+    def visit_bindparam(self, bindparam, within_columns_clause=False, **kwargs):
+        if within_columns_clause and bindparam.value is not None:
+             # Check for NullType FIRST to avoid CompileError
+             from sqlalchemy.types import NullType
+             if isinstance(bindparam.type, NullType):
+                 return super().visit_bindparam(bindparam, within_columns_clause=within_columns_clause, **kwargs)
+
+             # Firebird needs CAST for parameters in SELECT list
+             # SELECT ? -> SELECT CAST(? AS <type>)
+             db_type = self.dialect.type_compiler.process(bindparam.type)
+             if db_type and "NULL" not in db_type.upper():
+                  # Firebird CAST(.. AS TIMESTAMP(6)) is not valid, use CAST(.. AS TIMESTAMP)
+                  if "TIMESTAMP" in db_type and "(6)" in db_type:
+                       db_type = db_type.replace("(6)", "")
+                  elif "TIME" in db_type and "(6)" in db_type:
+                       db_type = db_type.replace("(6)", "")
+                  
+                  return f"CAST({super().visit_bindparam(bindparam, within_columns_clause=within_columns_clause, **kwargs)} AS {db_type})"
+        
+        ret = super().visit_bindparam(bindparam, within_columns_clause=within_columns_clause, **kwargs)
+        
+        # If we are NOT in the columns clause (e.g. WHERE, INSERT values), 
+        # modify the CAST(...) wrapper generated by the parent compiler.
+        # Firebird infers strict types from context (e.g. VARCHAR(2) col -> VARCHAR(2) param),
+        # which causes truncation for LIKE patterns longer than the column.
+        # We widen the CAST to VARCHAR(2000) to allow longer patterns.
+        # We avoid max length (32765) to prevent "Implementation limit exceeded" errors.
+        if not within_columns_clause and "CAST" in ret and "VARCHAR" in ret:
+             ret = re.sub(r'(VARCHAR|CHAR|NVARCHAR|NCHAR)\(\d+\)', r'\1(2000)', ret)
+        
+        return ret
+
+    def order_by_clause(self, select, **kw):
+        if isinstance(select, expression.CompoundSelect):
+            return self._compound_order_by_clause(select, **kw)
+        return super().order_by_clause(select, **kw)
+
+    def _compound_order_by_clause(self, select, **kw):
+        if not select._order_by_clauses:
+            return ""
+
+        pos_by_name = {}
+        for idx, col in enumerate(select.selected_columns, 1):
+            for key in (getattr(col, "key", None), getattr(col, "name", None)):
+                if key and key not in pos_by_name:
+                    pos_by_name[key] = idx
+
+        clauses = []
+        for clause in select._order_by_clauses:
+            elem = clause
+            direction = None
+
+            if isinstance(elem, elements.UnaryExpression) and elem.modifier in (
+                operators.asc_op,
+                operators.desc_op,
+            ):
+                direction = elem.modifier
+                elem = elem.element
+
+            if isinstance(elem, elements._label_reference):
+                elem = elem.element
+                if isinstance(elem, elements.UnaryExpression) and elem.modifier in (
+                    operators.asc_op,
+                    operators.desc_op,
+                ):
+                    direction = elem.modifier
+                    elem = elem.element
+
+            if isinstance(elem, elements._textual_label_reference):
+                key = elem.element
+            else:
+                key = getattr(elem, "key", None) or getattr(elem, "name", None)
+
+            if key in pos_by_name:
+                position = expression.literal_column(str(pos_by_name[key]))
+                if direction is operators.desc_op:
+                    position = position.desc()
+                elif direction is operators.asc_op:
+                    position = position.asc()
+                clauses.append(position)
+                continue
+
+            clauses.append(clause)
+
+        order_by = self._generate_delimited_list(
+            clauses, OPERATORS[operators.comma_op], **kw
+        )
+        if order_by:
+            return " ORDER BY " + order_by
+        return ""

sqlalchemy_firebird_async-0.2.2/src/sqlalchemy_firebird_async/fdb.py

@@ -0,0 +1,253 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial
+from sqlalchemy.util.concurrency import await_only
+from greenlet import getcurrent
+
+
+class AsyncCursor:
+    def __init__(self, sync_cursor, loop, executor=None):
+        self._sync_cursor = sync_cursor
+        self._loop = loop
+        self._executor = executor
+
+    def _exec(self, func, *args, **kwargs):
+        # Check whether we are in a SQLAlchemy-created greenlet context.
+        in_greenlet = getattr(getcurrent(), "__sqlalchemy_greenlet_provider__", None)
+        if self._executor is not None:
+            if in_greenlet:
+                return await_only(
+                    self._loop.run_in_executor(
+                        self._executor, partial(func, *args, **kwargs)
+                    )
+                )
+            return self._executor.submit(func, *args, **kwargs).result()
+        if in_greenlet:
+            return await_only(
+                self._loop.run_in_executor(None, partial(func, *args, **kwargs))
+            )
+        # If not, call synchronously (e.g. inside run_sync).
+        return func(*args, **kwargs)
+
+    def execute(self, operation, parameters=None):
+        if parameters is None:
+            return self._exec(self._sync_cursor.execute, operation)
+        else:
+            return self._exec(self._sync_cursor.execute, operation, parameters)
+
+    def executemany(self, operation, seq_of_parameters):
+        return self._exec(self._sync_cursor.executemany, operation, seq_of_parameters)
+
+    def fetchone(self):
+        return self._exec(self._sync_cursor.fetchone)
+
+    def fetchmany(self, size=None):
+        if size is None:
+            return self._exec(self._sync_cursor.fetchmany)
+        return self._exec(self._sync_cursor.fetchmany, size)
+
+    def fetchall(self):
+        return self._exec(self._sync_cursor.fetchall)
+
+    def close(self):
+        return self._exec(self._sync_cursor.close)
+    
+    async def _async_soft_close(self):
+        pass
+    
+    def nextset(self):
+        return self._exec(self._sync_cursor.nextset)
+
+    def __getattr__(self, name):
+        return getattr(self._sync_cursor, name)
+
+
+class AsyncConnection:
+    def __init__(self, sync_connection, loop, executor=None):
+        self._sync_connection = sync_connection
+        self._loop = loop
+        self._executor = executor
+
+    def _exec(self, func, *args, **kwargs):
+        in_greenlet = getattr(getcurrent(), "__sqlalchemy_greenlet_provider__", None)
+        if self._executor is not None:
+            if in_greenlet:
+                return await_only(
+                    self._loop.run_in_executor(
+                        self._executor, partial(func, *args, **kwargs)
+                    )
+                )
+            return self._executor.submit(func, *args, **kwargs).result()
+        if in_greenlet:
+            return await_only(
+                self._loop.run_in_executor(None, partial(func, *args, **kwargs))
+            )
+        return func(*args, **kwargs)
+
+    def cursor(self):
+        sync_cursor = self._exec(self._sync_connection.cursor)
+        return AsyncCursor(sync_cursor, self._loop, self._executor)
+
+    def begin(self):
+        return self._exec(self._sync_connection.begin)
+
+    def commit(self):
+        return self._exec(self._sync_connection.commit)
+
+    def rollback(self):
+        return self._exec(self._sync_connection.rollback)
+
+    def close(self):
+        try:
+            return self._exec(self._sync_connection.close)
+        finally:
+            if self._executor is not None:
+                self._executor.shutdown(wait=False)
+                self._executor = None
+    
+    def terminate(self):
+        return self.close()
+
+    def __getattr__(self, name):
+        return getattr(self._sync_connection, name)
+
+
+class AsyncDBAPI:
+    def __init__(self, sync_dbapi):
+        self._sync_dbapi = sync_dbapi
+        self.paramstyle = getattr(sync_dbapi, "paramstyle", "qmark")
+        self.apilevel = getattr(sync_dbapi, "apilevel", "2.0")
+        self.threadsafety = getattr(sync_dbapi, "threadsafety", 0)
+        for attr in (
+            "Warning",
+            "Error",
+            "InterfaceError",
+            "DatabaseError",
+            "DataError",
+            "OperationalError",
+            "IntegrityError",
+            "InternalError",
+            "ProgrammingError",
+            "NotSupportedError",
+        ):
+            if hasattr(sync_dbapi, attr):
+                setattr(self, attr, getattr(sync_dbapi, attr))
+
+    def connect(self, *args, **kwargs):
+        async_creator_fn = kwargs.pop("async_creator_fn", None)
+        loop = asyncio.get_running_loop()
+        executor = None
+        
+        def _connect():
+            if async_creator_fn is not None:
+                # We cannot call await_only directly if the creator is async.
+                # But fdb is synchronous, so it is fine.
+                # If async_creator is provided, it is for firebirdsql, but we are in fdb.py.
+                return async_creator_fn(*args, **kwargs) # Returns a coroutine? No, this is a callback.
+            else:
+                return self._sync_dbapi.connect(*args, **kwargs)
+
+        if getattr(getcurrent(), "__sqlalchemy_greenlet_provider__", None):
+            # If async_creator_fn returns a coroutine, await_only will wait for it.
+            # But for fdb this is sync, so use run_in_executor.
+             executor = ThreadPoolExecutor(max_workers=1)
+             try:
+                 sync_conn = await_only(loop.run_in_executor(executor, _connect))
+             except Exception:
+                 executor.shutdown(wait=False)
+                 raise
+        else:
+             sync_conn = _connect()
+            
+        return AsyncConnection(sync_conn, loop, executor)
+
+from sqlalchemy.pool import AsyncAdaptedQueuePool
+from sqlalchemy_firebird.base import FBExecutionContext
+import sqlalchemy_firebird.fdb as fdb
+from .compiler import PatchedFBCompiler, PatchedFBDDLCompiler, PatchedFBTypeCompiler
+from .types import FBCHARCompat, FBVARCHARCompat
+from sqlalchemy import String, DateTime, Time, TIMESTAMP, VARCHAR, CHAR
+from .types import _FBSafeString, FBDateTime, FBTime, FBTimestamp
+
+
+class AsyncFDBExecutionContext(FBExecutionContext):
+    def post_exec(self):
+        super().post_exec()
+        if self.isddl:
+            # Firebird with fdb requires a new transaction to see DDL changes.
+            dbapi_conn = self._dbapi_connection
+            driver_conn = getattr(dbapi_conn, "driver_connection", None)
+            if driver_conn is None:
+                driver_conn = getattr(dbapi_conn, "dbapi_connection", dbapi_conn)
+            try:
+                self.cursor.close()
+            except Exception:
+                pass
+            driver_conn.commit()
+            driver_conn.begin()
+
+
+class AsyncFDBDialect(fdb.FBDialect_fdb):
+    name = "firebird.fdb_async"
+    driver = "fdb_async"
+    is_async = True
+    supports_statement_cache = False
+    poolclass = AsyncAdaptedQueuePool
+    statement_compiler = PatchedFBCompiler
+    ddl_compiler = PatchedFBDDLCompiler
+    execution_ctx_cls = AsyncFDBExecutionContext
+    ischema_names = fdb.FBDialect_fdb.ischema_names.copy()
+    ischema_names["TEXT"] = FBCHARCompat
+    ischema_names["VARYING"] = FBVARCHARCompat
+    ischema_names["CSTRING"] = FBVARCHARCompat
+    
+    colspecs = fdb.FBDialect_fdb.colspecs.copy()
+    colspecs[String] = _FBSafeString
+    colspecs[VARCHAR] = _FBSafeString
+    colspecs[CHAR] = _FBSafeString
+    colspecs[DateTime] = FBDateTime
+    colspecs[Time] = FBTime
+    colspecs[TIMESTAMP] = FBTimestamp
+
+    # Explicitly set type compiler to ensure our patch is used
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.type_compiler_instance = PatchedFBTypeCompiler(self)
+        self.type_compiler = self.type_compiler_instance
+
+    def dbapi_exception_translation(self, exception, statement, parameters, context):
+        from sqlalchemy import exc
+        
+        msg = str(exception).lower()
+        if "violation" in msg and ("primary" in msg or "unique" in msg or "foreign" in msg or "constraint" in msg):
+             return exc.IntegrityError(statement, parameters, exception)
+             
+        return super().dbapi_exception_translation(exception, statement, parameters, context)
+
+    def wrap_dbapi_exception(self, e, statement, parameters, cursor, context):
+        from sqlalchemy import exc
+        
+        msg = str(e).lower()
+        if "violation" in msg and ("primary" in msg or "unique" in msg or "foreign" in msg or "constraint" in msg):
+             return exc.IntegrityError(statement, parameters, e)
+             
+        return super().wrap_dbapi_exception(e, statement, parameters, cursor, context)
+
+    def is_disconnect(self, e, connection, cursor):
+        # Handle fdb disconnect errors which store error code in args[1]
+        # Base implementation checks for self.driver == "fdb"
+        if isinstance(e, self.dbapi.DatabaseError):
+             # We are essentially fdb
+             return (e.args[1] in (335546001, 335546003, 335546005)) or \
+                    ("Error writing data to the connection" in str(e))
+        return super().is_disconnect(e, connection, cursor)
+
+    @classmethod
+    def import_dbapi(cls):
+        import fdb as sync_fdb
+
+        return AsyncDBAPI(sync_fdb)
+
+    @classmethod
+    def dbapi(cls):
+        return cls.import_dbapi()