chore: initial commit

async_msssql_query.py

@@ -0,0 +1,93 @@
+# async_msssql_query.py — loop-safe, compat rows=list, no pooling
+from __future__ import annotations
+
+import asyncio, urllib.parse, time, logging
+from typing import Any, Dict, Optional
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.pool import NullPool
+from sqlalchemy import text
+
+try:
+    import orjson as _json
+    def _dumps(obj: Any) -> str: return _json.dumps(obj, default=str).decode("utf-8")
+except Exception:
+    import json as _json
+    def _dumps(obj: Any) -> str: return _json.dumps(obj, default=str)
+
+def make_mssql_dsn(
+    *, server: str, database: str, user: Optional[str]=None, password: Optional[str]=None,
+    driver: str="ODBC Driver 17 for SQL Server", trust_server_certificate: bool=True,
+    encrypt: Optional[str]=None, extra_odbc_kv: Optional[Dict[str,str]]=None
+) -> str:
+    kv = {"DRIVER": driver, "SERVER": server, "DATABASE": database,
+          "TrustServerCertificate": "Yes" if trust_server_certificate else "No"}
+    if user: kv["UID"] = user
+    if password: kv["PWD"] = password
+    if encrypt: kv["Encrypt"] = encrypt
+    if extra_odbc_kv: kv.update(extra_odbc_kv)
+    odbc = ";".join(f"{k}={v}" for k,v in kv.items()) + ";"
+    return f"mssql+aioodbc:///?odbc_connect={urllib.parse.quote_plus(odbc)}"
+
+class AsyncMSSQLClient:
+    """
+    Engine creato pigramente sul loop corrente, senza pool (NullPool).
+    Evita “Future attached to a different loop” nei reset/close del pool.
+    """
+    def __init__(self, dsn: str, *, echo: bool=False, log: bool=True):
+        self._dsn = dsn
+        self._echo = echo
+        self._engine = None
+        self._engine_loop: Optional[asyncio.AbstractEventLoop] = None
+        self._logger = logging.getLogger("AsyncMSSQLClient")
+        if log and not self._logger.handlers:
+            h = logging.StreamHandler()
+            h.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+            self._logger.addHandler(h)
+        self._enable_log = log
+
+    async def _ensure_engine(self):
+        if self._engine is not None:
+            return
+        loop = asyncio.get_running_loop()
+        self._engine = create_async_engine(
+            self._dsn,
+            echo=self._echo,
+            # IMPORTANTI:
+            poolclass=NullPool,                 # no pooling → no reset su loop “sbagliati”
+            connect_args={"loop": loop},        # usa il loop corrente in aioodbc
+        )
+        self._engine_loop = loop
+        if self._enable_log:
+            self._logger.info("Engine created on loop %s", id(loop))
+
+    async def dispose(self):
+        if self._engine is None:
+            return
+        # sempre sullo stesso loop in cui è nato
+        if asyncio.get_running_loop() is self._engine_loop:
+            await self._engine.dispose()
+        else:
+            fut = asyncio.run_coroutine_threadsafe(self._engine.dispose(), self._engine_loop)
+            fut.result(timeout=2)
+        self._engine = None
+        if self._enable_log:
+            self._logger.info("Engine disposed")
+
+    async def query_json(self, sql: str, params: Optional[Dict[str, Any]]=None, *, as_dict_rows: bool=False) -> Dict[str, Any]:
+        await self._ensure_engine()
+        t0 = time.perf_counter()
+        async with self._engine.connect() as conn:
+            res = await conn.execute(text(sql), params or {})
+            rows = res.fetchall()
+            cols = list(res.keys())
+        if as_dict_rows:
+            rows_out = [dict(zip(cols, r)) for r in rows]
+        else:
+            rows_out = [list(r) for r in rows]
+        return {"columns": cols, "rows": rows_out, "elapsed_ms": round((time.perf_counter()-t0)*1000, 3)}
+
+    async def exec(self, sql: str, params: Optional[Dict[str, Any]]=None, *, commit: bool=False) -> int:
+        await self._ensure_engine()
+        async with (self._engine.begin() if commit else self._engine.connect()) as conn:
+            res = await conn.execute(text(sql), params or {})
+            return res.rowcount or 0