fix: resolve SQLite path mismatch and ambiguity false positives

adapters/db/sqlite_adapter.py

@@ -17,8 +17,9 @@ class SQLiteAdapter(DBAdapter):
         log.info("SQLiteAdapter initialized with DB path: %s", self.path)
 
     def preview_schema(self, limit_per_table: int = 0) -> str:
-        uri = self.path.as_uri()
-        with sqlite3.connect(f"{uri}?mode=ro", uri=True) as conn:
+        if not self.path.exists():
+            raise FileNotFoundError(f"SQLite DB does not exist: {self.path}")
+        with sqlite3.connect(f"file:{self.path}?mode=ro", uri=True) as conn:
             cur = conn.cursor()
             cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
             tables = [t[0] for t in cur.fetchall()]
@@ -30,12 +31,12 @@ class SQLiteAdapter(DBAdapter):
             return "\n".join(lines)
 
     def execute(self, sql: str) -> Tuple[List[Tuple[Any, ...]], List[str]]:
-        # enforce read-only connection
-        uri = self.path.as_uri()
-        log.info("SQLiteAdapter opening read-only connection to: %s", uri)
         if not self.path.exists():
             raise FileNotFoundError(f"SQLite DB does not exist: {self.path}")
-        with sqlite3.connect(f"{uri}?mode=ro", uri=True, timeout=3) as conn:
+        # use proper SQLite URI (not .as_uri())
+        uri = f"file:{self.path}?mode=ro"
+        log.info("SQLiteAdapter opening read-only connection to: %s", uri)
+        with sqlite3.connect(uri, uri=True, timeout=3) as conn:
             cur = conn.cursor()
             log.debug("Executing SQL: %s", sql.strip().replace("\n", " "))
             cur.execute(sql)

app/routers/nl2sql.py

@@ -17,7 +17,7 @@ from prometheus_client import Counter
 
 # --- Local ---
 from app.schemas import NL2SQLRequest, NL2SQLResponse, ClarifyResponse
-from app.state import get_db_path, cleanup_stale_dbs, register_db
+from app.state import cleanup_stale_dbs, register_db
 from nl2sql.pipeline import FinalResult, FinalResult as _FinalResult
 from adapters.llm.openai_provider import OpenAIProvider
 from adapters.db.sqlite_adapter import SQLiteAdapter
@@ -145,7 +145,7 @@ _PIPELINE = pipeline_from_config(CONFIG_PATH)
 # -------------------------------
 def _select_adapter(db_id: Optional[str]) -> Union[PostgresAdapter, SQLiteAdapter]:
     """
-    Resolve a DB adapter based on module-level DB_MODE and an optional db_id.
+    Resolve DB adapter path for SQLite or Postgres.
     """
     if DB_MODE == "postgres":
         dsn = os.environ.get("POSTGRES_DSN")
@@ -153,24 +153,28 @@ def _select_adapter(db_id: Optional[str]) -> Union[PostgresAdapter, SQLiteAdapte
             raise HTTPException(status_code=500, detail="POSTGRES_DSN env is missing")
         return PostgresAdapter(dsn)
 
-    # sqlite mode
     if db_id:
         cleanup_stale_dbs()
-        path = get_db_path(db_id)
+        import logging
 
-        if not path or not os.path.exists(path):
-            tmp_path = Path("/tmp/nl2sql_dbs") / f"{db_id}.sqlite"
-            if tmp_path.exists():
-                path = str(tmp_path)
+        log = logging.getLogger(__name__)
 
-        if path and os.path.exists(path):
-            return SQLiteAdapter(str(path))
+        candidates = [
+            Path("/tmp/nl2sql_dbs") / f"{db_id}.sqlite",
+            Path("/tmp/nl2sql_dbs") / f"{db_id}.db",
+            Path("data/uploads") / f"{db_id}.sqlite",
+            Path("data/uploads") / f"{db_id}.db",
+            Path("data") / f"{db_id}.sqlite",
+            Path("data") / f"{db_id}.db",
+        ]
 
-        raise HTTPException(
-            status_code=404, detail=f"db_id not found or expired: {db_id}"
-        )
+        for candidate in candidates:
+            if candidate.exists():
+                log.info(f"✅ Using DB file: {candidate}")
+                return SQLiteAdapter(str(candidate))
+
+        raise HTTPException(status_code=404, detail=f"db_id not found: {db_id}")
 
-    # default sqlite fallback
     default_path = Path(DEFAULT_SQLITE_PATH)
     if not default_path.exists():
         raise HTTPException(status_code=500, detail="default SQLite DB not found")

app/state.py

@@ -1,24 +1,72 @@
 import os
 import time
-from typing import Dict, Any
+import logging
+from pathlib import Path
+from typing import Optional
 
-DB_TTL_SECONDS = int(os.getenv("NL2SQL_DB_TTL_SEC", "86400"))
-DB_MAP: Dict[str, Dict[str, Any]] = {}
+log = logging.getLogger(__name__)
 
+# ------------------------------
+# Config
+# ------------------------------
 
-def register_db(db_id: str, path: str) -> None:
-    DB_MAP[db_id] = {"path": path, "created_at": time.time()}
+# default upload directory (can override via .env)
+_DB_UPLOAD_DIR = Path(os.getenv("DB_UPLOAD_DIR", "/tmp/nl2sql_dbs"))
+_DB_UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
 
+# in-memory map: {db_id: {"path": str, "ts": float}}
+DB_MAP: dict[str, dict[str, str | float]] = {}
 
-def get_db_path(db_id: str) -> str | None:
-    entry = DB_MAP.get(db_id)
-    return entry["path"] if entry else None
+# cleanup threshold (hours)
+DB_TTL_HOURS = 6
+
+
+# ------------------------------
+# Helpers
+# ------------------------------
+
+
+def register_db(db_id: str, path: str) -> None:
+    """Register new DB in memory (and ensure dir exists)."""
+    _DB_UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+    DB_MAP[db_id] = {"path": path, "ts": time.time()}
+    log.info(f"📦 Registered DB {db_id} -> {path}")
 
 
 def cleanup_stale_dbs() -> None:
+    """Remove expired DBs from /tmp/nl2sql_dbs and memory map."""
     now = time.time()
-    stale = [
-        k for k, v in DB_MAP.items() if now - v.get("created_at", now) > DB_TTL_SECONDS
+    cutoff = DB_TTL_HOURS * 3600
+    stale_ids = [db_id for db_id, entry in DB_MAP.items() if now - entry["ts"] > cutoff]
+    for db_id in stale_ids:
+        path = DB_MAP[db_id]["path"]
+        try:
+            os.remove(path)
+            log.info(f"🧹 Deleted stale DB: {path}")
+        except FileNotFoundError:
+            pass
+        DB_MAP.pop(db_id, None)
+
+
+def get_db_path(db_id: str) -> Optional[str]:
+    """Return full path of an uploaded DB (persistent lookup)."""
+    # ⃣ in-memory lookup
+    entry = DB_MAP.get(db_id)
+    if entry and Path(entry["path"]).exists():
+        return entry["path"]
+
+    # ⃣ persistent fallback scan
+    candidates = [
+        _DB_UPLOAD_DIR / f"{db_id}.sqlite",
+        _DB_UPLOAD_DIR / f"{db_id}.db",
+        Path("data/uploads") / f"{db_id}.sqlite",
+        Path("data/uploads") / f"{db_id}.db",
     ]
-    for k in stale:
-        DB_MAP.pop(k, None)
+    for p in candidates:
+        if p.exists():
+            log.info(f"🔍 Recovered DB path for {db_id}: {p}")
+            return str(p)
+
+    # ⃣ not found
+    log.warning(f"⚠️ DB file not found for id={db_id}")
+    return None

nl2sql/ambiguity_detector.py

@@ -1,16 +1,43 @@
+import os
 import re
+import logging
+
+log = logging.getLogger(__name__)
 
 
 class AmbiguityDetector:
-    """Lightweight AmbiSQL-style ambiguity detection."""
+    """Improved AmbiSQL-style ambiguity detection.
+
+    - Skips detection entirely in DEV_MODE.
+    - Ignores qualified references like 'artist.name'.
+    """
 
-    AMBIGUOUS_TERMS = ["recent", "top", "name", "rank", "latest"]
+    AMBIGUOUS_TERMS = [
+        "recent",
+        "top",
+        "name",
+        "rank",
+        "latest",
+        "id",
+        "title",
+        "date",
+        "type",
+    ]
 
     def detect(self, query: str, schema_preview: str) -> list[str]:
-        hits = []
+        # Normalize query
         q_lower = query.lower()
+
+        # Skip ambiguity checks entirely in dev mode
+        if os.getenv("DEV_MODE") == "1":
+            log.warning("Skipping ambiguity detection (DEV_MODE=1).")
+            return []
+
+        hits = []
         for term in self.AMBIGUOUS_TERMS:
-            if re.search(rf"\b{term}\b", q_lower):
-                hits.append(f"The term '{term}' is ambiguous in this query.'")
+            # Match only standalone words, not qualified like 'artist.name'
+            pattern = rf"(?<!\.)\b{term}\b"
+            if re.search(pattern, q_lower):
+                hits.append(f"The term '{term}' is ambiguous in this query.")
 
         return hits