fix: close oracle round 16 gaps

- Wrap raw non-DB-API exceptions (TypeError, ImportError) during backend
  construction as OperationalError
- Translate Graph token-provider failures at execution time to InterfaceError
- Replace .lower() with .casefold() for Unicode-safe identifier comparison
  in executor, parser, and base engine
- Reset lastrowid to None at start of execute() to prevent stale values

Author: yeongseon

src/excel_dbapi/connection.py

@@ -23,6 +23,7 @@
 from .engines.result import ExecutionResult
 from .exceptions import (
     DatabaseError,
+    Error,
     InterfaceError,
     NotSupportedError,
     OperationalError,
@@ -173,8 +174,9 @@ def __init__(
                 and isinstance(exc, InvalidFileException)
             ):
                 raise OperationalError(str(exc)) from exc
-            # Re-raise other unexpected exceptions
-            raise
+            if isinstance(exc, Error):
+                raise
+            raise OperationalError(str(exc)) from exc
 
         # Guard: non-transactional backends reject autocommit=False
         if not autocommit and not getattr(self.engine, "supports_transactions", True):

src/excel_dbapi/cursor.py

@@ -73,6 +73,7 @@ def execute(self, query: str, params: Sequence[Any] | None = None) -> "ExcelCurs
         self.description = None
         self.rowcount = -1
         self._has_result_set = False
+        self.lastrowid = None
         try:
             result: ExecutionResult = self.connection.execute(query, params)
         except ValueError as exc:

src/excel_dbapi/engines/base.py

@@ -261,7 +261,7 @@ def _normalize_headers(raw: list[Any]) -> list[str]:
     seen: set[str] = set()
     lower_map: dict[str, str] = {}
     for h in headers:
-        key = h.lower()
+        key = h.casefold()
         if key in seen:
             raise DataError(
                 f"Duplicate header: {h!r} (conflicts with {lower_map[key]!r})"

src/excel_dbapi/engines/graph/client.py

@@ -7,7 +7,7 @@
 
 import httpx
 
-from ...exceptions import InterfaceError, OperationalError
+from ...exceptions import Error, InterfaceError, OperationalError
 from .auth import TokenProvider
 
 _BASE_URL = "https://graph.microsoft.com/v1.0"
@@ -92,8 +92,17 @@ def close(self) -> None:
     # -- internals -----------------------------------------------------------
 
     def _build_headers(self) -> dict[str, str]:
+        try:
+            token = self._token_provider.get_token()
+        except Exception as exc:
+            if isinstance(exc, Error):
+                raise
+            raise InterfaceError(
+                f"Failed to acquire authentication token: {exc}"
+            ) from exc
+
         headers: dict[str, str] = {
-            "Authorization": f"Bearer {self._token_provider.get_token()}",
+            "Authorization": f"Bearer {token}",
             "Content-Type": "application/json",
         }
         if self._session_id is not None:

src/excel_dbapi/executor.py

@@ -825,7 +825,7 @@ def _resolve_upsert_column(column_name: str) -> Any:
             columns = parsed["columns"]
             seen: set[str] = set()
             for col in columns:
-                lower = col.lower()
+                lower = col.casefold()
                 if lower in seen:
                     raise ValueError(f"Duplicate column name '{col}' in CREATE TABLE")
                 seen.add(lower)
@@ -888,8 +888,8 @@ def _resolve_upsert_column(column_name: str) -> Any:
 
             if operation == "ADD_COLUMN":
                 col = parsed["column"]
-                if col in data.headers or col.lower() in {
-                    h.lower() for h in data.headers
+                if col in data.headers or col.casefold() in {
+                    h.casefold() for h in data.headers
                 }:
                     raise ValueError(f"Column '{col}' already exists in '{table}'")
                 data.headers.append(col)
@@ -3733,13 +3733,13 @@ def _to_number(self, value: Any) -> float | None:
 
     def _resolve_sheet_name(self, requested_name: str) -> str | None:
         sheets = self.backend.list_sheets()
-        lowered = {name.lower(): name for name in sheets}
-        return lowered.get(requested_name.lower())
+        lowered = {name.casefold(): name for name in sheets}
+        return lowered.get(requested_name.casefold())
 
     def _resolve_cte_name(self, requested_name: str) -> str | None:
-        lowered = requested_name.lower()
+        lowered = requested_name.casefold()
         for name in self._cte_tables:
-            if name.lower() == lowered:
+            if name.casefold() == lowered:
                 return name
         return None
 

src/excel_dbapi/parser.py

@@ -5059,7 +5059,7 @@ def _parse_compound(
 
 
 def _query_references_name(query: Dict[str, Any], name: str) -> bool:
-    lowered = name.lower()
+    lowered = name.casefold()
     action = str(query.get("action", "")).upper()
     if action == "COMPOUND":
         for branch in query.get("queries", []):
@@ -5071,7 +5071,7 @@ def _query_references_name(query: Dict[str, Any], name: str) -> bool:
         return False
 
     for source in _query_source_references(query):
-        if source.lower() == lowered:
+        if source.casefold() == lowered:
             return True
     return False
 
@@ -5100,7 +5100,7 @@ def _parse_with_query(
         cte_name = tokens[index]
         if not re.fullmatch(_IDENTIFIER_PATTERN, cte_name):
             raise ValueError(f"Invalid CTE name: {cte_name}")
-        lowered_name = cte_name.lower()
+        lowered_name = cte_name.casefold()
         if lowered_name in cte_names:
             raise ValueError(f"Duplicate CTE name: {cte_name}")
         cte_names.add(lowered_name)

tests/test_oracle_round16_fixes.py

@@ -0,0 +1,78 @@
+from pathlib import Path
+from typing import Any, cast
+
+import httpx
+import pytest
+from openpyxl import Workbook
+
+from excel_dbapi import connect
+from excel_dbapi.connection import ExcelConnection
+from excel_dbapi.exceptions import Error, OperationalError, ProgrammingError
+
+
+def _create_workbook(
+    path: Path, sheet: str, headers: list[object], rows: list[list[object]]
+) -> None:
+    workbook = Workbook()
+    worksheet = workbook.active
+    assert worksheet is not None
+    worksheet.title = sheet
+    worksheet.append(headers)
+    for row in rows:
+        worksheet.append(row)
+    workbook.save(path)
+    workbook.close()
+
+
+def test_graph_invalid_credential_is_wrapped_as_operational_error() -> None:
+    with pytest.raises(OperationalError, match="Cannot normalise"):
+        connect(
+            "msgraph://drives/d/items/i",
+            engine="graph",
+            credential=cast(Any, 42),
+        )
+
+
+def test_graph_token_provider_failure_is_translated_during_execute() -> None:
+    class ExplodingTokenProvider:
+        def get_token(self, *args: Any) -> Any:
+            del args
+            raise RuntimeError("token boom")
+
+    transport = httpx.MockTransport(lambda request: httpx.Response(200, json={}))
+    with ExcelConnection(
+        "msgraph://drives/drv-test/items/itm-test",
+        engine="graph",
+        credential=ExplodingTokenProvider(),
+        transport=transport,
+    ) as conn:
+        cursor = conn.cursor()
+        with pytest.raises(
+            Error, match="Failed to acquire authentication token: token boom"
+        ):
+            cursor.execute("SELECT * FROM Employees")
+
+
+def test_executor_resolves_unicode_sheet_names_with_casefold(tmp_path: Path) -> None:
+    file_path = tmp_path / "unicode-sheet-casefold.xlsx"
+    _create_workbook(file_path, "Straße", ["id"], [[1]])
+
+    with ExcelConnection(str(file_path), engine="openpyxl") as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM STRASSE")
+        assert cursor.fetchall() == [(1,)]
+
+
+def test_lastrowid_is_cleared_after_failed_execute(tmp_path: Path) -> None:
+    file_path = tmp_path / "lastrowid-reset.xlsx"
+    _create_workbook(file_path, "Sheet1", ["id", "name"], [[1, "Alice"]])
+
+    with ExcelConnection(str(file_path), engine="openpyxl") as conn:
+        cursor = conn.cursor()
+        cursor.execute("INSERT INTO Sheet1 VALUES (2, 'Bob')")
+        assert cursor.lastrowid is not None
+
+        with pytest.raises(ProgrammingError):
+            cursor.execute("SELECT * FROM MissingSheet")
+
+        assert cursor.lastrowid is None