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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-firebird-async
-Version: 0.2.0
+Version: 0.2.1
 Summary: Asyncio support for Firebird in SQLAlchemy
 Project-URL: Homepage, https://github.com/attid/sqlalchemy-firebird-async
 Author-email: Igor Tolstov <attid0@gmail.com>

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlalchemy-firebird-async"
-version = "0.2.0"
+version = "0.2.1"
 description = "Asyncio support for Firebird in SQLAlchemy"
 readme = "README.md"
 authors = [

{sqlalchemy_firebird_async-0.2.0 → sqlalchemy_firebird_async-0.2.1}/src/sqlalchemy_firebird_async/fdb.py

@@ -72,6 +72,9 @@ class AsyncConnection:
 
     def close(self):
         return self._exec(self._sync_connection.close)
+    
+    def terminate(self):
+        return self._exec(self._sync_connection.close)
 
     def __getattr__(self, name):
         return getattr(self._sync_connection, name)

{sqlalchemy_firebird_async-0.2.0 → sqlalchemy_firebird_async-0.2.1}/src/sqlalchemy_firebird_async/firebird_driver.py

@@ -73,6 +73,9 @@ class AsyncConnection:
 
     def close(self):
         return self._exec(self._sync_connection.close)
+    
+    def terminate(self):
+        return self._exec(self._sync_connection.close)
 
     def __getattr__(self, name):
         return getattr(self._sync_connection, name)

sqlalchemy_firebird_async-0.2.1/tests/test_terminate.py

@@ -0,0 +1,59 @@
+import pytest
+from sqlalchemy import text
+
+@pytest.mark.asyncio
+async def test_engine_terminate(async_engine):
+    """
+    Тест проверяет корректность закрытия соединений при dispose.
+    Это должно вызывать do_terminate -> terminate.
+    """
+    # 1. Открываем соединение
+    async with async_engine.connect() as conn:
+        await conn.execute(text("SELECT 1 FROM rdb$database"))
+        # Не закрываем явно (хотя контекст менеджер закроет)
+        
+    # 2. Форсируем закрытие пула
+    # dispose() вызывает pool.dispose(), который закрывает все соединения.
+    # Если пул был QueuePool (стандартный), он может попытаться вызвать terminate
+    # для проверенных соединений, если они считаются "invalid" или при очистке.
+    
+    # Чтобы гарантированно вызвать terminate, можно попробовать сымитировать ошибку
+    # или просто положиться на то, что пул вызывает terminate при сбросе.
+    
+    await async_engine.dispose()
+    
+    # 3. Прямой тест метода terminate на объекте соединения (низкоуровневый)
+    # Нам нужно добраться до raw connection
+    raw_conn = await async_engine.raw_connection()
+    try:
+        # В SQLAlchemy 2.0+ raw_connection возвращает адаптер
+        # Нам нужно вызвать метод terminate, который ожидает диалект
+        if hasattr(raw_conn, "terminate"):
+             raw_conn.terminate()
+        else:
+             # Если метода нет, это уже ошибка (AttributeError бы вылетел выше, если бы вызов шел)
+             # Но ошибка из стектрейса пользователя была в do_terminate диалекта
+             
+             # Эмулируем то, что делает пул:
+             # dialect.do_terminate(dbapi_connection)
+             dialect = async_engine.dialect
+             # raw_conn это AsyncAdapt_dbapi_connection
+             # Внутри него .dbapi_connection это наш AsyncConnection
+             
+             # Но terminate вызывается у dbapi_connection.
+             # Попробуем вызвать его у нашего AsyncConnection
+             real_conn = raw_conn.driver_connection
+             
+             # Проверяем наличие метода, так как его отсутствие вызывает ошибку
+             # Если мы его не добавим, тут будет AttributeError (если вызывать)
+             
+             # Эмуляция вызова из диалекта:
+             try:
+                 dialect.do_terminate(real_conn)
+             except AttributeError as e:
+                 if "'terminate'" in str(e):
+                     pytest.fail(f"Missing terminate method: {e}")
+                 else:
+                     raise e
+    finally:
+        raw_conn.close()

sqlalchemy_firebird_async-0.2.1/tests/test_types.py

@@ -0,0 +1,141 @@
+import pytest
+import decimal
+import datetime
+from sqlalchemy import text
+
+@pytest.mark.asyncio
+async def test_primitive_types(async_engine):
+    """Тест базовых типов: INT, BIGINT, FLOAT, BOOLEAN, VARCHAR, DECIMAL."""
+    # 1. DDL
+    async with async_engine.begin() as conn:
+        try: await conn.execute(text("DROP TABLE all_types"))
+        except Exception: pass
+        
+        await conn.execute(text("""
+            CREATE TABLE all_types (
+                id INTEGER PRIMARY KEY,
+                f_integer INTEGER,
+                f_bigint BIGINT,
+                f_float FLOAT,
+                f_boolean BOOLEAN,
+                f_string VARCHAR(100),
+                f_decimal DECIMAL(10, 2)
+            )
+        """))
+
+    # 2. DML
+    test_data = {
+        "id": 1,
+        "f_integer": 42,
+        "f_bigint": 9223372036854775807,
+        "f_float": 3.14159,
+        "f_boolean": True,
+        "f_string": "Hello Firebird",
+        "f_decimal": decimal.Decimal("123.45")
+    }
+
+    async with async_engine.begin() as conn:
+        await conn.execute(
+            text("""
+                INSERT INTO all_types (id, f_integer, f_bigint, f_float, f_boolean, f_string, f_decimal)
+                VALUES (:id, :f_integer, :f_bigint, :f_float, :f_boolean, :f_string, :f_decimal)
+            """),
+            test_data
+        )
+
+    # 3. SELECT
+    async with async_engine.connect() as conn:
+        result = await conn.execute(text("SELECT * FROM all_types WHERE id = 1"))
+        row = result.fetchone()
+        assert row.f_integer == 42
+        assert row.f_bigint == 9223372036854775807
+        assert abs(row.f_float - 3.14159) < 0.00001
+        assert row.f_boolean is True
+        assert row.f_string == "Hello Firebird"
+        assert row.f_decimal == decimal.Decimal("123.45")
+
+@pytest.mark.asyncio
+async def test_complex_types_fb4(async_engine):
+    """
+    Тестирование сложных типов FB4 (INT128, Time Zones).
+    Пропускается для fdb_async, так как старый драйвер их не поддерживает.
+    """
+    if "fdb_async" in async_engine.url.drivername:
+        pytest.skip("fdb driver does not support INT128 or Time Zones")
+
+    now_tz = datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0)
+    test_val_38 = decimal.Decimal("1234567890123456789012345678.9012345678")
+    test_blob = "Very large text blob " * 100
+
+    async with async_engine.begin() as conn:
+        try: await conn.execute(text("DROP TABLE complex_types"))
+        except Exception: pass
+        await conn.execute(text("""
+            CREATE TABLE complex_types (
+                id INTEGER PRIMARY KEY,
+                f_numeric_38 NUMERIC(38, 10),
+                f_timestamp_tz TIMESTAMP WITH TIME ZONE,
+                f_blob BLOB SUB_TYPE TEXT
+            )
+        """))
+
+    async with async_engine.begin() as conn:
+        await conn.execute(
+            text("""
+                INSERT INTO complex_types (id, f_numeric_38, f_timestamp_tz, f_blob)
+                VALUES (:id, :f_numeric_38, :f_timestamp_tz, :f_blob)
+            """),
+            {"id": 1, "f_numeric_38": test_val_38, "f_timestamp_tz": now_tz, "f_blob": test_blob}
+        )
+
+    async with async_engine.connect() as conn:
+        result = await conn.execute(text("SELECT * FROM complex_types WHERE id = 1"))
+        row = result.fetchone()
+        assert row.f_numeric_38 == test_val_38
+        assert isinstance(row.f_timestamp_tz, datetime.datetime)
+        assert abs(row.f_timestamp_tz.timestamp() - now_tz.timestamp()) < 1.0
+        assert row.f_blob == test_blob
+
+@pytest.mark.asyncio
+async def test_aggregations(async_engine):
+    """Проверка агрегатных функций."""
+    if "fdb_async" in async_engine.url.drivername:
+        pytest.skip("fdb driver has issues with SQLDA for aggregations in async wrapper")
+
+    async with async_engine.begin() as conn:
+        try: await conn.execute(text("DROP TABLE test_agg"))
+        except Exception: pass
+        await conn.execute(text("CREATE TABLE test_agg (val DECIMAL(10,2))"))
+    
+    async with async_engine.begin() as conn:
+        for v in [10.5, 20.5, 30.0]:
+            await conn.execute(text("INSERT INTO test_agg (val) VALUES (:v)"), {"v": v})
+        
+    async with async_engine.connect() as conn:
+        res = await conn.execute(text("SELECT SUM(val), COUNT(*) FROM test_agg"))
+        s, c = res.fetchone()
+        assert s == decimal.Decimal("61.00")
+        assert c == 3
+
+@pytest.mark.asyncio
+async def test_insert_returning(async_engine):
+    """Проверка RETURNING."""
+    async with async_engine.begin() as conn:
+        try: await conn.execute(text("DROP TABLE test_ret"))
+        except Exception: pass
+        await conn.execute(text("CREATE TABLE test_ret (id INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, name VARCHAR(50))"))
+    
+    async with async_engine.begin() as conn:
+        res = await conn.execute(
+            text("INSERT INTO test_ret (name) VALUES (:name) RETURNING id"),
+            {"name": "test"}
+        )
+        new_id = res.scalar()
+        assert isinstance(new_id, int)
+
+@pytest.mark.asyncio
+async def test_statement_string_compilation(async_engine):
+    """Проверка компиляции запроса в строку (для print)."""
+    stmt = text("SELECT 1 FROM rdb$database WHERE 1 = :id").bindparams(id=1)
+    compiled_str = str(stmt.compile(async_engine.sync_engine))
+    assert "1 = " in compiled_str