sqlalchemy-excel 0.1.1__tar.gz → 0.2.0__tar.gz

{sqlalchemy_excel-0.1.1 → sqlalchemy_excel-0.2.0}/.github/workflows/ci.yml

@@ -34,6 +34,13 @@ jobs:
         run: |
           mypy --strict src/
 
-      - name: Test
+      - name: Run tests with coverage
         run: |
-          pytest -v --tb=short
+          pytest tests/ -v --cov=sqlalchemy_excel --cov-report=xml --cov-report=term-missing
+
+      - name: Upload coverage to Codecov
+        if: matrix.python-version == '3.12'
+        uses: codecov/codecov-action@v5
+        with:
+          files: ./coverage.xml
+          fail_ci_if_error: false

sqlalchemy_excel-0.2.0/PKG-INFO

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: sqlalchemy-excel
+Version: 0.2.0
+Summary: SQLAlchemy dialect for Excel files — use Excel as a database
+Project-URL: Homepage, https://github.com/yeongseon/sqlalchemy-excel
+Project-URL: Repository, https://github.com/yeongseon/sqlalchemy-excel
+Project-URL: Issues, https://github.com/yeongseon/sqlalchemy-excel/issues
+Author: Yeongseon Choe
+License: MIT
+License-File: LICENSE
+Keywords: database,dialect,excel,openpyxl,sqlalchemy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Office/Business :: Financial :: Spreadsheet
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: excel-dbapi>=0.2.0
+Requires-Dist: sqlalchemy>=2.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sqlalchemy-excel
+
+![CI](https://github.com/yeongseon/sqlalchemy-excel/actions/workflows/ci.yml/badge.svg)
+[![codecov](https://codecov.io/gh/yeongseon/sqlalchemy-excel/branch/main/graph/badge.svg)](https://codecov.io/gh/yeongseon/sqlalchemy-excel)
+[![PyPI](https://img.shields.io/pypi/v/sqlalchemy-excel.svg)](https://pypi.org/project/sqlalchemy-excel/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+SQLAlchemy dialect for Excel files — use Excel as a database.
+
+```python
+from sqlalchemy import create_engine, Column, Integer, String
+from sqlalchemy.orm import DeclarativeBase, Session, Mapped, mapped_column
+
+engine = create_engine("excel:///data.xlsx")
+
+class Base(DeclarativeBase):
+    pass
+
+class User(Base):
+    __tablename__ = "Sheet1"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column()
+
+Base.metadata.create_all(engine)
+
+with Session(engine) as session:
+    session.add(User(id=1, name="Alice"))
+    session.commit()
+
+with Session(engine) as session:
+    users = session.query(User).all()
+```
+
+## Installation
+
+```bash
+pip install sqlalchemy-excel
+```
+
+`excel-dbapi` is automatically installed as a dependency.
+
+## URL Format
+
+```python
+# Relative path
+engine = create_engine("excel:///data.xlsx")
+
+# Absolute path (note four slashes)
+engine = create_engine("excel:////home/user/data.xlsx")
+
+# With engine options
+engine = create_engine("excel:///data.xlsx", connect_args={"engine": "openpyxl"})
+```
+
+## Features
+
+- Full SQLAlchemy 2.0 dialect
+- PEP 249 DB-API 2.0 compliant driver ([excel-dbapi](https://github.com/yeongseon/excel-dbapi))
+- SELECT with WHERE, ORDER BY, LIMIT
+- INSERT, UPDATE, DELETE
+- CREATE TABLE / DROP TABLE with metadata tracking
+- IN, BETWEEN, LIKE operators in WHERE clauses
+- ORM support with `DeclarativeBase`
+- Schema inspection (`get_table_names`, `get_columns`, `has_table`)
+- Type mapping: String, Integer, Float, Boolean, Date, DateTime
+
+## Type Mapping
+
+| SQLAlchemy Type | Excel Storage | Notes |
+|---|---|---|
+| `String`, `Text`, `VARCHAR`, `CHAR` | TEXT | All string types map to TEXT |
+| `Integer`, `SmallInteger`, `BigInteger` | INTEGER | All integer types map to INTEGER |
+| `Float`, `Numeric`, `Decimal` | FLOAT | All numeric types map to FLOAT |
+| `Boolean` | BOOLEAN | |
+| `Date` | DATE | |
+| `DateTime`, `TIMESTAMP` | DATETIME | |
+| `Time` | TEXT | Stored as text |
+| `Uuid` | TEXT | Stored as text |
+
+> BLOB, BINARY, JSON, and ARRAY types are not supported and will raise `CompileError`.
+
+## ORM Examples
+
+### Define a Model
+
+```python
+from sqlalchemy import create_engine
+from sqlalchemy.orm import DeclarativeBase, Session, Mapped, mapped_column
+
+engine = create_engine("excel:///data.xlsx")
+
+class Base(DeclarativeBase):
+    pass
+
+class User(Base):
+    __tablename__ = "users"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column()
+    age: Mapped[int] = mapped_column()
+
+Base.metadata.create_all(engine)
+```
+
+### Insert
+
+```python
+with Session(engine) as session:
+    session.add(User(id=1, name="Alice", age=30))
+    session.add(User(id=2, name="Bob", age=25))
+    session.commit()
+```
+
+### Query with Filters
+
+```python
+from sqlalchemy import select
+
+with Session(engine) as session:
+    # Basic query
+    users = session.query(User).all()
+
+    # WHERE clause
+    user = session.query(User).filter(User.name == "Alice").first()
+
+    # IN operator
+    stmt = select(User).where(User.name.in_(["Alice", "Bob"]))
+    users = session.scalars(stmt).all()
+
+    # BETWEEN operator
+    stmt = select(User).where(User.age.between(25, 35))
+    users = session.scalars(stmt).all()
+
+    # LIKE operator
+    stmt = select(User).where(User.name.like("A%"))
+    users = session.scalars(stmt).all()
+
+    # ORDER BY + LIMIT
+    stmt = select(User).order_by(User.age.desc()).limit(5)
+    users = session.scalars(stmt).all()
+```
+
+### Update and Delete
+
+```python
+with Session(engine) as session:
+    user = session.query(User).filter(User.id == 1).first()
+    if user:
+        user.name = "Ann"
+        session.commit()
+
+with Session(engine) as session:
+    user = session.query(User).filter(User.id == 2).first()
+    if user:
+        session.delete(user)
+        session.commit()
+```
+
+## Core Usage
+
+```python
+from sqlalchemy import create_engine, text
+
+engine = create_engine("excel:///data.xlsx")
+
+with engine.connect() as conn:
+    result = conn.execute(text("SELECT * FROM Sheet1"))
+    for row in result:
+        print(row)
+```
+
+## Schema Inspection
+
+```python
+from sqlalchemy import create_engine, inspect
+
+engine = create_engine("excel:///data.xlsx")
+inspector = inspect(engine)
+
+# List all sheets (tables)
+print(inspector.get_table_names())
+
+# Get column info
+print(inspector.get_columns("Sheet1"))
+
+# Check if a sheet exists
+print(inspector.has_table("Sheet1"))
+```
+
+## Limitations
+
+- No JOIN, GROUP BY, HAVING, DISTINCT, OFFSET
+- No subqueries, CTEs, or aggregate functions
+- No ALTER TABLE, foreign keys, or indexes
+- Single-table operations only
+- No concurrent writes — use a single-writer model
+
+## Related Projects
+
+- [excel-dbapi](https://github.com/yeongseon/excel-dbapi) — The underlying PEP 249 DB-API 2.0 driver for Excel files.
+
+## License
+
+MIT

sqlalchemy_excel-0.2.0/README.md

@@ -0,0 +1,204 @@
+# sqlalchemy-excel
+
+![CI](https://github.com/yeongseon/sqlalchemy-excel/actions/workflows/ci.yml/badge.svg)
+[![codecov](https://codecov.io/gh/yeongseon/sqlalchemy-excel/branch/main/graph/badge.svg)](https://codecov.io/gh/yeongseon/sqlalchemy-excel)
+[![PyPI](https://img.shields.io/pypi/v/sqlalchemy-excel.svg)](https://pypi.org/project/sqlalchemy-excel/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+SQLAlchemy dialect for Excel files — use Excel as a database.
+
+```python
+from sqlalchemy import create_engine, Column, Integer, String
+from sqlalchemy.orm import DeclarativeBase, Session, Mapped, mapped_column
+
+engine = create_engine("excel:///data.xlsx")
+
+class Base(DeclarativeBase):
+    pass
+
+class User(Base):
+    __tablename__ = "Sheet1"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column()
+
+Base.metadata.create_all(engine)
+
+with Session(engine) as session:
+    session.add(User(id=1, name="Alice"))
+    session.commit()
+
+with Session(engine) as session:
+    users = session.query(User).all()
+```
+
+## Installation
+
+```bash
+pip install sqlalchemy-excel
+```
+
+`excel-dbapi` is automatically installed as a dependency.
+
+## URL Format
+
+```python
+# Relative path
+engine = create_engine("excel:///data.xlsx")
+
+# Absolute path (note four slashes)
+engine = create_engine("excel:////home/user/data.xlsx")
+
+# With engine options
+engine = create_engine("excel:///data.xlsx", connect_args={"engine": "openpyxl"})
+```
+
+## Features
+
+- Full SQLAlchemy 2.0 dialect
+- PEP 249 DB-API 2.0 compliant driver ([excel-dbapi](https://github.com/yeongseon/excel-dbapi))
+- SELECT with WHERE, ORDER BY, LIMIT
+- INSERT, UPDATE, DELETE
+- CREATE TABLE / DROP TABLE with metadata tracking
+- IN, BETWEEN, LIKE operators in WHERE clauses
+- ORM support with `DeclarativeBase`
+- Schema inspection (`get_table_names`, `get_columns`, `has_table`)
+- Type mapping: String, Integer, Float, Boolean, Date, DateTime
+
+## Type Mapping
+
+| SQLAlchemy Type | Excel Storage | Notes |
+|---|---|---|
+| `String`, `Text`, `VARCHAR`, `CHAR` | TEXT | All string types map to TEXT |
+| `Integer`, `SmallInteger`, `BigInteger` | INTEGER | All integer types map to INTEGER |
+| `Float`, `Numeric`, `Decimal` | FLOAT | All numeric types map to FLOAT |
+| `Boolean` | BOOLEAN | |
+| `Date` | DATE | |
+| `DateTime`, `TIMESTAMP` | DATETIME | |
+| `Time` | TEXT | Stored as text |
+| `Uuid` | TEXT | Stored as text |
+
+> BLOB, BINARY, JSON, and ARRAY types are not supported and will raise `CompileError`.
+
+## ORM Examples
+
+### Define a Model
+
+```python
+from sqlalchemy import create_engine
+from sqlalchemy.orm import DeclarativeBase, Session, Mapped, mapped_column
+
+engine = create_engine("excel:///data.xlsx")
+
+class Base(DeclarativeBase):
+    pass
+
+class User(Base):
+    __tablename__ = "users"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column()
+    age: Mapped[int] = mapped_column()
+
+Base.metadata.create_all(engine)
+```
+
+### Insert
+
+```python
+with Session(engine) as session:
+    session.add(User(id=1, name="Alice", age=30))
+    session.add(User(id=2, name="Bob", age=25))
+    session.commit()
+```
+
+### Query with Filters
+
+```python
+from sqlalchemy import select
+
+with Session(engine) as session:
+    # Basic query
+    users = session.query(User).all()
+
+    # WHERE clause
+    user = session.query(User).filter(User.name == "Alice").first()
+
+    # IN operator
+    stmt = select(User).where(User.name.in_(["Alice", "Bob"]))
+    users = session.scalars(stmt).all()
+
+    # BETWEEN operator
+    stmt = select(User).where(User.age.between(25, 35))
+    users = session.scalars(stmt).all()
+
+    # LIKE operator
+    stmt = select(User).where(User.name.like("A%"))
+    users = session.scalars(stmt).all()
+
+    # ORDER BY + LIMIT
+    stmt = select(User).order_by(User.age.desc()).limit(5)
+    users = session.scalars(stmt).all()
+```
+
+### Update and Delete
+
+```python
+with Session(engine) as session:
+    user = session.query(User).filter(User.id == 1).first()
+    if user:
+        user.name = "Ann"
+        session.commit()
+
+with Session(engine) as session:
+    user = session.query(User).filter(User.id == 2).first()
+    if user:
+        session.delete(user)
+        session.commit()
+```
+
+## Core Usage
+
+```python
+from sqlalchemy import create_engine, text
+
+engine = create_engine("excel:///data.xlsx")
+
+with engine.connect() as conn:
+    result = conn.execute(text("SELECT * FROM Sheet1"))
+    for row in result:
+        print(row)
+```
+
+## Schema Inspection
+
+```python
+from sqlalchemy import create_engine, inspect
+
+engine = create_engine("excel:///data.xlsx")
+inspector = inspect(engine)
+
+# List all sheets (tables)
+print(inspector.get_table_names())
+
+# Get column info
+print(inspector.get_columns("Sheet1"))
+
+# Check if a sheet exists
+print(inspector.has_table("Sheet1"))
+```
+
+## Limitations
+
+- No JOIN, GROUP BY, HAVING, DISTINCT, OFFSET
+- No subqueries, CTEs, or aggregate functions
+- No ALTER TABLE, foreign keys, or indexes
+- Single-table operations only
+- No concurrent writes — use a single-writer model
+
+## Related Projects
+
+- [excel-dbapi](https://github.com/yeongseon/excel-dbapi) — The underlying PEP 249 DB-API 2.0 driver for Excel files.
+
+## License
+
+MIT

{sqlalchemy_excel-0.1.1 → sqlalchemy_excel-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlalchemy-excel"
-version = "0.1.1"
+version = "0.2.0"
 description = "SQLAlchemy dialect for Excel files — use Excel as a database"
 readme = "README.md"
 license = {text = "MIT"}
@@ -29,7 +29,7 @@ classifiers = [
 
 dependencies = [
     "sqlalchemy>=2.0",
-    "excel-dbapi>=0.1.1",
+    "excel-dbapi>=0.2.0",
 ]
 
 [project.optional-dependencies]

{sqlalchemy_excel-0.1.1 → sqlalchemy_excel-0.2.0}/src/sqlalchemy_excel/__init__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from .dialect import ExcelDialect
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"
 
 __all__ = [
     "ExcelDialect",

{sqlalchemy_excel-0.1.1 → sqlalchemy_excel-0.2.0}/src/sqlalchemy_excel/compiler.py

@@ -22,11 +22,14 @@ So we override the identifier preparer to never use table prefixes.
 
 from __future__ import annotations
 
-from typing import Any, ClassVar
+from typing import TYPE_CHECKING, Any, Literal
 
 from sqlalchemy import exc
 from sqlalchemy.sql import compiler, elements
 
+if TYPE_CHECKING:
+    from collections.abc import MutableMapping
+
 
 class ExcelIdentifierPreparer(compiler.IdentifierPreparer):
     """Identifier preparer that never quotes identifiers.
@@ -35,10 +38,9 @@ class ExcelIdentifierPreparer(compiler.IdentifierPreparer):
     or table prefixes.
     """
 
-    reserved_words: ClassVar[set[str]] = set()
-
     def __init__(self, dialect: Any) -> None:
         super().__init__(dialect, initial_quote="", final_quote="")
+        self.reserved_words = set()
 
     def quote_identifier(self, value: str) -> str:
         return value
@@ -55,7 +57,9 @@ class ExcelCompiler(compiler.SQLCompiler):
         column: Any,
         add_to_result_map: Any = None,
         include_table: bool = True,
-        **kw: Any,
+        result_map_targets: tuple[Any, ...] = (),
+        ambiguous_table_name_map: MutableMapping[str, str] | None = None,
+        **kwargs: Any,
     ) -> str:
         """Override to never include table prefix in column references.
 
@@ -67,7 +71,9 @@ class ExcelCompiler(compiler.SQLCompiler):
             column,
             add_to_result_map=add_to_result_map,
             include_table=False,
-            **kw,
+            result_map_targets=result_map_targets,
+            ambiguous_table_name_map=ambiguous_table_name_map,
+            **kwargs,
         )
 
     def visit_label(
@@ -104,11 +110,13 @@ class ExcelCompiler(compiler.SQLCompiler):
                 )
 
             # Emit the column WITHOUT "AS <label>"
-            return label.element._compiler_dispatch(
-                self,
-                within_columns_clause=True,
-                within_label_clause=True,
-                **kw,
+            return str(
+                label.element._compiler_dispatch(
+                    self,
+                    within_columns_clause=True,
+                    within_label_clause=True,
+                    **kw,
+                )
             )
 
         if render_label_as_label is label:
@@ -118,11 +126,19 @@ class ExcelCompiler(compiler.SQLCompiler):
                 labelname = label.name
             return self.preparer.format_label(label, labelname)
 
-        return label.element._compiler_dispatch(self, within_columns_clause=False, **kw)
+        return str(
+            label.element._compiler_dispatch(self, within_columns_clause=False, **kw)
+        )
 
     # ── Unsupported feature guards ─────────────────────────
 
-    def visit_join(self, join: Any, **kw: Any) -> str:
+    def visit_join(
+        self,
+        join: Any,
+        asfrom: Any = False,
+        from_linter: Any = None,
+        **kwargs: Any,
+    ) -> str:
         raise exc.CompileError("Excel dialect does not support JOIN")
 
     def group_by_clause(self, select: Any, **kw: Any) -> str:
@@ -141,7 +157,17 @@ class ExcelCompiler(compiler.SQLCompiler):
             raise exc.CompileError("Excel dialect does not support OFFSET")
         return text
 
-    def visit_cte(self, cte: Any, **kw: Any) -> str:
+    def visit_cte(
+        self,
+        cte: Any,
+        asfrom: bool = False,
+        ashint: bool = False,
+        fromhints: dict[Any, str] | None = None,
+        visiting_cte: Any = None,
+        from_linter: Any = None,
+        cte_opts: Any = None,
+        **kwargs: Any,
+    ) -> str | None:
         raise exc.CompileError("Excel dialect does not support CTEs")
 
     def visit_subquery(self, subquery: Any, **kw: Any) -> str:
@@ -155,5 +181,9 @@ class ExcelCompiler(compiler.SQLCompiler):
     ) -> str:
         raise exc.CompileError("Excel dialect does not support RETURNING")
 
-    def for_update_clause(self, select: Any, **kw: Any) -> str:
+    def for_update_clause(
+        self,
+        select: Any,
+        **kw: Any,
+    ) -> Literal[" FOR UPDATE"]:
         raise exc.CompileError("Excel dialect does not support SELECT ... FOR UPDATE")

{sqlalchemy_excel-0.1.1 → sqlalchemy_excel-0.2.0}/src/sqlalchemy_excel/ddl.py

@@ -38,7 +38,13 @@ class ExcelDDLCompiler(compiler.DDLCompiler):
         table_name = self.preparer.format_table(table)
         return f"DROP TABLE {table_name}"
 
-    def visit_create_index(self, create: Any, **kw: Any) -> str:
+    def visit_create_index(
+        self,
+        create: Any,
+        include_schema: Any = False,
+        include_table_schema: Any = True,
+        **kw: Any,
+    ) -> str:
         raise exc.CompileError("Excel dialect does not support CREATE INDEX")
 
     def visit_drop_index(self, drop: Any, **kw: Any) -> str:
@@ -50,7 +56,12 @@ class ExcelDDLCompiler(compiler.DDLCompiler):
     def visit_drop_constraint(self, drop: Any, **kw: Any) -> str:
         raise exc.CompileError("Excel dialect does not support constraints")
 
-    def visit_create_sequence(self, create: Any, **kw: Any) -> str:
+    def visit_create_sequence(
+        self,
+        create: Any,
+        prefix: Any = None,
+        **kw: Any,
+    ) -> str:
         raise exc.CompileError("Excel dialect does not support sequences")
 
     def visit_drop_sequence(self, drop: Any, **kw: Any) -> str:

{sqlalchemy_excel-0.1.1 → sqlalchemy_excel-0.2.0}/src/sqlalchemy_excel/dialect.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import TYPE_CHECKING, Any, Literal, cast
 
 from sqlalchemy import event, pool
 from sqlalchemy.engine import default
@@ -17,6 +17,7 @@ from .types import ExcelTypeCompiler
 if TYPE_CHECKING:
     from sqlalchemy.engine import URL
     from sqlalchemy.engine.interfaces import ConnectArgsType
+    from sqlalchemy.sql.compiler import IdentifierPreparer
 
 
 def _after_create(
@@ -67,7 +68,10 @@ event.listen(Table, "after_create", _after_create)
 event.listen(Table, "after_drop", _after_drop)
 
 
-class ExcelDialect(ExcelInspectionMixin, default.DefaultDialect):  # type: ignore[misc]
+class ExcelDialect(  # type: ignore[misc]  # pyright: ignore[reportIncompatibleMethodOverride]
+    ExcelInspectionMixin,
+    default.DefaultDialect,
+):
     """SQLAlchemy dialect for Excel files via excel-dbapi.
 
     Connection URLs::
@@ -81,30 +85,32 @@ class ExcelDialect(ExcelInspectionMixin, default.DefaultDialect):  # type: ignor
 
     """
 
-    name: ClassVar[str] = "excel"
-    driver: ClassVar[str] = "dbapi"
-    default_paramstyle: ClassVar[str] = "qmark"
+    name: str = "excel"
+    driver: str = "dbapi"
+    default_paramstyle: str = "qmark"
 
     # ── Feature flags ──────────────────────────────────────
-    supports_alter: ClassVar[bool] = False
-    supports_sequences: ClassVar[bool] = False
-    supports_schemas: ClassVar[bool] = False
-    supports_views: ClassVar[bool] = False
-    supports_native_boolean: ClassVar[bool] = True
-    supports_native_decimal: ClassVar[bool] = False
-    supports_statement_cache: ClassVar[bool] = False
-    supports_default_values: ClassVar[bool] = False
-    supports_default_metavalue: ClassVar[bool] = False
-    supports_empty_insert: ClassVar[bool] = False
-    supports_multivalues_insert: ClassVar[bool] = False
-    postfetch_lastrowid: ClassVar[bool] = False
-    insertmanyvalues_implicit_sentinel: ClassVar[Any] = None
+    supports_alter: bool = False
+    supports_sequences: bool = False
+    supports_schemas: bool = False
+    supports_views: bool = False
+    supports_native_boolean: bool = True
+    supports_native_decimal: bool = False
+    supports_statement_cache: bool = False
+    supports_default_values: bool = False
+    supports_default_metavalue: bool = False
+    supports_empty_insert: bool = False
+    supports_multivalues_insert: bool = False
+    postfetch_lastrowid: bool = False
+    insertmanyvalues_implicit_sentinel: Any = None
 
     # ── Compiler classes ──────────────────────────────────
     statement_compiler = ExcelCompiler
     ddl_compiler = ExcelDDLCompiler
     type_compiler_cls = ExcelTypeCompiler
-    preparer = ExcelIdentifierPreparer
+    preparer: type[IdentifierPreparer] = cast(
+        "type[IdentifierPreparer]", ExcelIdentifierPreparer
+    )
 
     @classmethod
     def import_dbapi(cls) -> Any:
@@ -140,7 +146,12 @@ class ExcelDialect(ExcelInspectionMixin, default.DefaultDialect):  # type: ignor
         if "engine" in query:
             kwargs["engine"] = query.pop("engine")
         if "autocommit" in query:
-            kwargs["autocommit"] = query.pop("autocommit").lower() in (
+            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",
@@ -180,7 +191,7 @@ class ExcelDialect(ExcelInspectionMixin, default.DefaultDialect):  # type: ignor
         """Excel connections don't have network-level disconnects."""
         return False
 
-    def get_default_isolation_level(self, dbapi_conn: Any) -> str:
+    def get_default_isolation_level(self, dbapi_conn: Any) -> Literal["SERIALIZABLE"]:
         return "SERIALIZABLE"
 
     def _check_unicode_returns(
@@ -202,7 +213,7 @@ class ExcelDialect(ExcelInspectionMixin, default.DefaultDialect):  # type: ignor
         import excel_dbapi
 
         raw_conn = connection.connection.dbapi_connection
-        return excel_dbapi.has_table(raw_conn, table_name)
+        return cast("bool", excel_dbapi.has_table(raw_conn, table_name))
 
     def do_begin(self, dbapi_connection: Any) -> None:
         """No-op: excel-dbapi doesn't have explicit BEGIN."""

{sqlalchemy_excel-0.1.1 → sqlalchemy_excel-0.2.0}/src/sqlalchemy_excel/reflection.py

@@ -6,11 +6,11 @@ tables (worksheets), columns, and primary keys from an Excel file.
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, cast
 
 from sqlalchemy import types as sa_types
 
-_TYPE_MAP: dict[str, type[sa_types.TypeEngine]] = {
+_TYPE_MAP: dict[str, type[sa_types.TypeEngine[Any]]] = {
     "TEXT": sa_types.String,
     "INTEGER": sa_types.Integer,
     "FLOAT": sa_types.Float,
@@ -20,7 +20,7 @@ _TYPE_MAP: dict[str, type[sa_types.TypeEngine]] = {
 }
 
 
-def _sa_type_from_name(type_name: str) -> sa_types.TypeEngine:
+def _sa_type_from_name(type_name: str) -> sa_types.TypeEngine[Any]:
     """Convert an excel-dbapi type name to a SQLAlchemy type instance."""
     cls = _TYPE_MAP.get(type_name.upper(), sa_types.String)
     return cls()
@@ -43,7 +43,7 @@ class ExcelInspectionMixin:
         import excel_dbapi
 
         raw_conn = connection.connection.dbapi_connection
-        return excel_dbapi.list_tables(raw_conn, include_meta=False)
+        return cast("list[str]", excel_dbapi.list_tables(raw_conn, include_meta=False))
 
     def get_view_names(
         self,

{sqlalchemy_excel-0.1.1 → sqlalchemy_excel-0.2.0}/tests/test_dml.py

@@ -134,6 +134,61 @@ class TestSelect:
             # Each row should have 2 columns
             assert len(rows[0]) == 2
 
+    def test_select_where_in(self, populated_engine, users_table):
+        with populated_engine.connect() as conn:
+            self._seed(conn, users_table)
+            stmt = select(users_table).where(
+                users_table.c.name.in_(["Alice", "Charlie"])
+            )
+            result = conn.execute(stmt)
+            rows = result.fetchall()
+            assert len(rows) == 2
+            names = {row[1] for row in rows}
+            assert names == {"Alice", "Charlie"}
+
+    def test_select_where_between(self, populated_engine, users_table):
+        with populated_engine.connect() as conn:
+            self._seed(conn, users_table)
+            stmt = select(users_table).where(users_table.c.age.between(26, 31))
+            result = conn.execute(stmt)
+            rows = result.fetchall()
+            assert len(rows) == 1
+            assert rows[0][1] == "Alice"
+
+    def test_select_where_like(self, populated_engine, users_table):
+        with populated_engine.connect() as conn:
+            self._seed(conn, users_table)
+            stmt = select(users_table).where(users_table.c.name.like("A%"))
+            result = conn.execute(stmt)
+            rows = result.fetchall()
+            assert len(rows) == 1
+            assert rows[0][1] == "Alice"
+
+    def test_select_where_like_contains(self, populated_engine, users_table):
+        with populated_engine.connect() as conn:
+            self._seed(conn, users_table)
+            stmt = select(users_table).where(users_table.c.name.like("%ob%"))
+            result = conn.execute(stmt)
+            rows = result.fetchall()
+            assert len(rows) == 1
+            assert rows[0][1] == "Bob"
+
+    def test_select_where_in_with_order_limit(self, populated_engine, users_table):
+        with populated_engine.connect() as conn:
+            self._seed(conn, users_table)
+            stmt = (
+                select(users_table)
+                .where(users_table.c.name.in_(["Alice", "Bob", "Charlie"]))
+                .order_by(users_table.c.age.desc())
+                .limit(2)
+            )
+            result = conn.execute(stmt)
+            rows = result.fetchall()
+            assert len(rows) == 2
+            # Charlie(35), Alice(30) — desc by age, limit 2
+            assert rows[0][1] == "Charlie"
+            assert rows[1][1] == "Alice"
+
 
 class TestUpdate:
     """Test UPDATE operations."""

sqlalchemy_excel-0.1.1/PKG-INFO

@@ -1,96 +0,0 @@
-Metadata-Version: 2.4
-Name: sqlalchemy-excel
-Version: 0.1.1
-Summary: SQLAlchemy dialect for Excel files — use Excel as a database
-Project-URL: Homepage, https://github.com/yeongseon/sqlalchemy-excel
-Project-URL: Repository, https://github.com/yeongseon/sqlalchemy-excel
-Project-URL: Issues, https://github.com/yeongseon/sqlalchemy-excel/issues
-Author: Yeongseon Choe
-License: MIT
-License-File: LICENSE
-Keywords: database,dialect,excel,openpyxl,sqlalchemy
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Database
-Classifier: Topic :: Office/Business :: Financial :: Spreadsheet
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Requires-Dist: excel-dbapi>=0.1.1
-Requires-Dist: sqlalchemy>=2.0
-Provides-Extra: dev
-Requires-Dist: mypy>=1.10; extra == 'dev'
-Requires-Dist: pytest-cov>=4.0; extra == 'dev'
-Requires-Dist: pytest>=8.0; extra == 'dev'
-Requires-Dist: ruff>=0.4; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# sqlalchemy-excel
-
-SQLAlchemy dialect for Excel files — use Excel as a database.
-
-```python
-from sqlalchemy import create_engine, Column, Integer, String
-from sqlalchemy.orm import DeclarativeBase, Session, Mapped, mapped_column
-
-engine = create_engine("excel:///data.xlsx")
-
-class Base(DeclarativeBase):
-    pass
-
-class User(Base):
-    __tablename__ = "Sheet1"
-    id: Mapped[int] = mapped_column(primary_key=True)
-    name: Mapped[str] = mapped_column()
-
-Base.metadata.create_all(engine)
-
-with Session(engine) as session:
-    session.add(User(id=1, name="Alice"))
-    session.commit()
-
-with Session(engine) as session:
-    users = session.query(User).all()
-```
-
-## Installation
-
-```bash
-pip install sqlalchemy-excel
-```
-
-## URL Format
-
-```python
-# Relative path
-engine = create_engine("excel:///data.xlsx")
-
-# Absolute path (note four slashes)
-engine = create_engine("excel:////home/user/data.xlsx")
-```
-
-## Features
-
-- Full SQLAlchemy 2.0 dialect
-- PEP 249 DB-API 2.0 compliant driver ([excel-dbapi](https://github.com/yeongseon/excel-dbapi))
-- SELECT with WHERE, ORDER BY, LIMIT
-- INSERT, UPDATE, DELETE
-- CREATE TABLE / DROP TABLE
-- ORM support with `DeclarativeBase`
-- Type mapping: String, Integer, Float, Boolean, Date, DateTime
-
-## Limitations
-
-- No JOIN, GROUP BY, HAVING, DISTINCT, OFFSET
-- No subqueries, CTEs, or aggregate functions
-- No ALTER TABLE, foreign keys, or indexes
-- Single-table operations only
-
-## License
-
-MIT

sqlalchemy_excel-0.1.1/README.md

@@ -1,64 +0,0 @@
-# sqlalchemy-excel
-
-SQLAlchemy dialect for Excel files — use Excel as a database.
-
-```python
-from sqlalchemy import create_engine, Column, Integer, String
-from sqlalchemy.orm import DeclarativeBase, Session, Mapped, mapped_column
-
-engine = create_engine("excel:///data.xlsx")
-
-class Base(DeclarativeBase):
-    pass
-
-class User(Base):
-    __tablename__ = "Sheet1"
-    id: Mapped[int] = mapped_column(primary_key=True)
-    name: Mapped[str] = mapped_column()
-
-Base.metadata.create_all(engine)
-
-with Session(engine) as session:
-    session.add(User(id=1, name="Alice"))
-    session.commit()
-
-with Session(engine) as session:
-    users = session.query(User).all()
-```
-
-## Installation
-
-```bash
-pip install sqlalchemy-excel
-```
-
-## URL Format
-
-```python
-# Relative path
-engine = create_engine("excel:///data.xlsx")
-
-# Absolute path (note four slashes)
-engine = create_engine("excel:////home/user/data.xlsx")
-```
-
-## Features
-
-- Full SQLAlchemy 2.0 dialect
-- PEP 249 DB-API 2.0 compliant driver ([excel-dbapi](https://github.com/yeongseon/excel-dbapi))
-- SELECT with WHERE, ORDER BY, LIMIT
-- INSERT, UPDATE, DELETE
-- CREATE TABLE / DROP TABLE
-- ORM support with `DeclarativeBase`
-- Type mapping: String, Integer, Float, Boolean, Date, DateTime
-
-## Limitations
-
-- No JOIN, GROUP BY, HAVING, DISTINCT, OFFSET
-- No subqueries, CTEs, or aggregate functions
-- No ALTER TABLE, foreign keys, or indexes
-- Single-table operations only
-
-## License
-
-MIT