fix: close oracle round 10 reflection and ddl gaps

Author: yeongseon

README.md

@@ -88,6 +88,9 @@ with Session(engine) as session:
     users = session.query(User).all()
 ```
 
+> **Note (development mode):** When using from source checkout (not pip-installed),
+> add `import sqlalchemy_excel` before `create_engine()` to register the dialect.
+
 ## URL Format
 
 ```python
@@ -249,7 +252,7 @@ with engine.connect() as conn:
 
 Reflection verifies that worksheets still exist before trusting metadata.
 If metadata remains for a deleted worksheet, sqlalchemy-excel removes the stale
-entry and returns an empty inspection result for that table name.
+entry and raises `NoSuchTableError` for that table name.
 
 Raw DDL executed through `text()` or `exec_driver_sql()` keeps metadata in sync
 for `CREATE TABLE`, `ALTER TABLE`, and `DROP TABLE`.
@@ -301,6 +304,9 @@ with engine.connect() as conn:
         print(row)
 ```
 
+> **Note (development mode):** When using from source checkout (not pip-installed),
+> add `import sqlalchemy_excel` before `create_engine()` to register the dialect.
+
 URL format: `excel+graph:///drive_id/item_id` where `drive_id` and `item_id` are Microsoft Graph resource identifiers.
 Query parameters: `?readonly=false` to enable write operations.
 

src/sqlalchemy_excel/ddl.py

@@ -54,6 +54,19 @@ def _warn_unsupported_constraints(
                     )
                     seen_check.add(check_key)
 
+    @staticmethod
+    def _warn_unsupported_generated_columns(column: Any) -> None:
+        if getattr(column, "computed", None) is not None:
+            warnings.warn(
+                f"Column '{column.name}': Computed columns are not supported by excel dialect; the expression will be ignored",
+                stacklevel=2,
+            )
+        if getattr(column, "identity", None) is not None:
+            warnings.warn(
+                f"Column '{column.name}': Identity columns are not supported by excel dialect; auto-increment will not be applied",
+                stacklevel=2,
+            )
+
     def _format_alter_table_name(self, operation: Any) -> str:
         schema = getattr(operation, "schema", None)
         if schema is not None:
@@ -104,6 +117,7 @@ def visit_create_table(self, create: Any, **kw: Any) -> str:
                 seen_unique=seen_unique,
                 seen_check=seen_check,
             )
+            self._warn_unsupported_generated_columns(col)
             suffix = f" {' '.join(constraints)}" if constraints else ""
             columns.append(f"{col_name} {col_type}{suffix}")
 
@@ -155,6 +169,7 @@ def visit_add_column(self, create: Any, **kw: Any) -> str:
             seen_unique=set(),
             seen_check=set(),
         )
+        self._warn_unsupported_generated_columns(column)
         suffix = f" {' '.join(constraints)}" if constraints else ""
         return f"ALTER TABLE {table_name} ADD COLUMN {col_name} {col_type}{suffix}"
 

src/sqlalchemy_excel/dialect.py

@@ -43,6 +43,16 @@ def _after_create(
                 "Excel dialect does not support autoincrement=True; value must be set explicitly",
                 stacklevel=2,
             )
+        if getattr(col, "computed", None) is not None:
+            warnings.warn(
+                f"Column '{col.name}': Computed columns are not supported by excel dialect; the expression will be ignored",
+                stacklevel=2,
+            )
+        if getattr(col, "identity", None) is not None:
+            warnings.warn(
+                f"Column '{col.name}': Identity columns are not supported by excel dialect; auto-increment will not be applied",
+                stacklevel=2,
+            )
 
     import excel_dbapi
 
@@ -172,11 +182,20 @@ def _driver_type_from_declared(type_expr: str) -> str:
     token = match.group(1) if match is not None else "TEXT"
     if token in {"FLOAT", "REAL", "DECIMAL", "NUMERIC", "DOUBLE"}:
         return "FLOAT"
+    if token in {"SMALLINT", "BIGINT"}:
+        return "INTEGER"
+    if token == "TIMESTAMP":
+        return "DATETIME"
     if token in {"INTEGER", "BOOLEAN", "DATE", "DATETIME", "TEXT"}:
         return token
     return "TEXT"
 
 
+def _coerce_bool_query_value(raw: Any) -> bool:
+    value = raw[0] if isinstance(raw, tuple) else raw
+    return str(value).lower() in ("true", "1", "yes")
+
+
 def _parse_alter_add_column(statement: str) -> tuple[str, str, str] | None:
     match = re.match(
         r'^ALTER TABLE\s+("[^"]+"|[A-Za-z_][A-Za-z0-9_]*)\s+ADD\s+COLUMN\s+("[^"]+"|[A-Za-z_][A-Za-z0-9_]*)\s+(.+?)\s*;?$',
@@ -325,21 +344,15 @@ def create_connect_args(self, url: URL) -> ConnectArgsType:
             "create": True,
         }
 
-        # Forward query parameters
         query = dict(url.query)
         if "engine" in query:
             kwargs["engine"] = query.pop("engine")
         if "autocommit" in query:
-            autocommit = query.pop("autocommit")
-            if isinstance(autocommit, tuple):
-                autocommit_text = autocommit[0] if autocommit else ""
-            else:
-                autocommit_text = autocommit
-            kwargs["autocommit"] = autocommit_text.lower() in (
-                "true",
-                "1",
-                "yes",
-            )
+            kwargs["autocommit"] = _coerce_bool_query_value(query.pop("autocommit"))
+
+        for key in ("data_only", "sanitize_formulas", "create", "file_locking"):
+            if key in query:
+                kwargs[key] = _coerce_bool_query_value(query[key])
 
         return ([], kwargs)
 
@@ -430,6 +443,10 @@ def _extract_declared_type_name(type_expr: str) -> str | None:
     @staticmethod
     def _normalize_metadata_type_name(type_name: str) -> str:
         normalized = type_name.upper()
+        if normalized in {"SMALLINT", "BIGINT"}:
+            return "INTEGER"
+        if normalized == "TIMESTAMP":
+            return "DATETIME"
         if normalized in {
             "FLOAT",
             "REAL",
@@ -736,8 +753,6 @@ def create_connect_args(self, url: URL) -> ConnectArgsType:
 
         query = dict(url.query)
         if "readonly" in query:
-            raw = query.pop("readonly")
-            val = raw[0] if isinstance(raw, tuple) else raw
-            kwargs["readonly"] = str(val).lower() in ("true", "1", "yes")
+            kwargs["readonly"] = _coerce_bool_query_value(query.pop("readonly"))
 
         return ([], kwargs)

src/sqlalchemy_excel/reflection.py

@@ -9,10 +9,13 @@
 from typing import Any, cast
 
 from sqlalchemy import types as sa_types
+from sqlalchemy.exc import NoSuchTableError
 
 _TYPE_MAP: dict[str, type[sa_types.TypeEngine[Any]]] = {
     "TEXT": sa_types.String,
     "INTEGER": sa_types.Integer,
+    "SMALLINT": sa_types.Integer,
+    "BIGINT": sa_types.Integer,
     "FLOAT": sa_types.Float,
     "REAL": sa_types.Float,
     "DECIMAL": sa_types.Float,
@@ -22,6 +25,7 @@
     "BOOLEAN": sa_types.Boolean,
     "DATE": sa_types.Date,
     "DATETIME": sa_types.DateTime,
+    "TIMESTAMP": sa_types.DateTime,
 }
 
 
@@ -83,7 +87,7 @@ def get_columns(
             meta = None
 
         if not table_exists:
-            return []
+            raise NoSuchTableError(table_name)
 
         if meta is not None:
             return [
@@ -130,7 +134,7 @@ def get_pk_constraint(
             meta = None
 
         if not table_exists:
-            return {"constrained_columns": [], "name": None}
+            raise NoSuchTableError(table_name)
 
         if meta is not None:
             pk_cols = [col["name"] for col in meta if col.get("primary_key", False)]

tests/test_default_guards.py

@@ -2,7 +2,17 @@
 
 import warnings
 
-from sqlalchemy import Column, Integer, MetaData, String, Table, create_engine, text
+from sqlalchemy import (
+    Column,
+    Computed,
+    Identity,
+    Integer,
+    MetaData,
+    String,
+    Table,
+    create_engine,
+    text,
+)
 
 
 def test_server_default_emits_warning(tmp_xlsx: str) -> None:
@@ -68,3 +78,50 @@ def test_normal_columns_do_not_emit_default_warnings(tmp_xlsx: str) -> None:
     messages = [str(item.message) for item in caught]
     assert not any("Excel dialect does not support" in message for message in messages)
     engine.dispose()
+
+
+def test_computed_column_emits_warning(tmp_xlsx: str) -> None:
+    engine = create_engine(f"excel:///{tmp_xlsx}")
+    metadata = MetaData()
+    _ = Table(
+        "with_computed",
+        metadata,
+        Column("id", Integer, primary_key=True),
+        Column("name", String),
+        Column("name_upper", String, Computed("name")),
+    )
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        metadata.create_all(engine)
+
+    messages = [str(item.message) for item in caught]
+    assert any(
+        "Computed columns are not supported by excel dialect; the expression will be ignored"
+        in message
+        for message in messages
+    )
+    engine.dispose()
+
+
+def test_identity_column_emits_warning(tmp_xlsx: str) -> None:
+    engine = create_engine(f"excel:///{tmp_xlsx}")
+    metadata = MetaData()
+    _ = Table(
+        "with_identity",
+        metadata,
+        Column("id", Integer, Identity(), primary_key=True),
+        Column("name", String),
+    )
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        metadata.create_all(engine)
+
+    messages = [str(item.message) for item in caught]
+    assert any(
+        "Identity columns are not supported by excel dialect; auto-increment will not be applied"
+        in message
+        for message in messages
+    )
+    engine.dispose()

tests/test_dialect.py

@@ -91,6 +91,22 @@ def test_connect_args_percent_decodes_local_path(self):
         assert kwargs["file_path"] == "folder name/test file.xlsx"
         engine.dispose()
 
+    def test_connect_args_forwards_data_only_query_param(self):
+        engine = create_engine("excel:///placeholder.xlsx")
+        dialect = engine.dialect
+        url = make_url("excel:///placeholder.xlsx?data_only=false")
+        _, kwargs = dialect.create_connect_args(url)
+        assert kwargs["data_only"] is False
+        engine.dispose()
+
+    def test_connect_args_forwards_create_query_param(self):
+        engine = create_engine("excel:///placeholder.xlsx")
+        dialect = engine.dialect
+        url = make_url("excel:///placeholder.xlsx?create=false")
+        _, kwargs = dialect.create_connect_args(url)
+        assert kwargs["create"] is False
+        engine.dispose()
+
 
 class TestConnection:
     """Test basic connection operations."""

tests/test_e2e.py

@@ -3502,6 +3502,23 @@ def test_e2e_raw_create_table_numeric_aliases_reflect_as_float(tmp_path) -> None
     engine.dispose()
 
 
+def test_e2e_raw_create_table_integer_and_timestamp_aliases_reflect_correctly(
+    tmp_path,
+) -> None:
+    engine = _engine_for(tmp_path)
+
+    with engine.begin() as conn:
+        conn.exec_driver_sql("CREATE TABLE t (a SMALLINT, ts TIMESTAMP, b BIGINT)")
+
+    inspector = inspect(engine)
+    columns = {column["name"]: column["type"] for column in inspector.get_columns("t")}
+    assert isinstance(columns["a"], sa.Integer)
+    assert isinstance(columns["b"], sa.Integer)
+    assert isinstance(columns["ts"], sa.DateTime)
+
+    engine.dispose()
+
+
 def test_e2e_raw_drop_table_removes_metadata(tmp_path) -> None:
     engine = _engine_for(tmp_path)
 
@@ -3519,7 +3536,8 @@ def test_e2e_raw_drop_table_removes_metadata(tmp_path) -> None:
 
     inspector = inspect(engine)
     assert inspector.has_table("users") is False
-    assert inspector.get_columns("users") == []
+    with pytest.raises(exc.NoSuchTableError):
+        inspector.get_columns("users")
 
     with engine.connect() as conn:
         import excel_dbapi

tests/test_reflection_full.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from sqlalchemy import create_engine, inspect, text
+import pytest
+from sqlalchemy import create_engine, exc, inspect, text
 
 
 def _engine_for(tmp_path):
@@ -63,11 +64,10 @@ def test_reflection_cleans_stale_metadata_when_sheet_is_missing(tmp_path) -> Non
         assert excel_dbapi.read_table_metadata(raw_conn, "ghost") is not None
 
     inspector = inspect(engine)
-    assert inspector.get_columns("ghost") == []
-    assert inspector.get_pk_constraint("ghost") == {
-        "constrained_columns": [],
-        "name": None,
-    }
+    with pytest.raises(exc.NoSuchTableError):
+        inspector.get_columns("ghost")
+    with pytest.raises(exc.NoSuchTableError):
+        inspector.get_pk_constraint("ghost")
 
     with engine.connect() as conn:
         import excel_dbapi