excel-dbapi 0.1.0__tar.gz

excel_dbapi-0.1.0/.gitignore

@@ -0,0 +1,91 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environment
+.venv/
+venv/
+env/
+ENV/
+
+# Python cache
+*.log
+*.pot
+*.pyc
+*.pyo
+*.pyd
+*.db
+*.sqlite3
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Hatch build artifacts
+*.hatch
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Lint & type checking
+.mypy_cache/
+.dmypy.json
+.pyre/
+ruff_cache/
+
+# pre-commit
+.pre-commit-config.yaml
+.pre-commit-config.yaml.lock
+.pre-commit-hooks.yaml
+.pre-commit-hooks.yaml.lock
+
+# dotenv
+.env
+.env.*
+*.env
+
+# IDEs & editors
+.vscode/
+.idea/
+*.sublime-project
+*.sublime-workspace
+
+# Mac OS
+.DS_Store
+
+# Windows
+Thumbs.db
+ehthumbs.db
+desktop.ini
+
+# Poetry
+poetry.lock

excel_dbapi-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yeongseon Choe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

excel_dbapi-0.1.0/Makefile

@@ -0,0 +1,43 @@
+.PHONY: install format lint type-check sec-check dead-code test build clean
+
+.PHONY: install-dev install-prod
+
+install-dev:
+	pip install .[dev]
+	hatch develop
+
+install-prod:
+	pip install .
+
+
+format:
+	black .
+	isort .
+
+lint:
+	ruff check .
+	mypy .
+
+type-check:
+	mypy .
+
+sec-check:
+	bandit -r src
+
+dead-code:
+	vulture src
+
+test:
+	pytest
+
+build:
+	python -m build
+
+clean:
+	rm -rf dist build *.egg-info
+
+publish-test:
+	twine upload --repository testpypi dist/*
+
+publish:
+	twine upload dist/*

excel_dbapi-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: excel-dbapi
+Version: 0.1.0
+Summary: A DBAPI-like interface for Excel files with extensible engines
+Author-email: Yeongseon Choe <yeongseon.choe@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: bandit<2.0.0,>=1.7.0; extra == 'dev'
+Requires-Dist: black<26.0.0,>=25.1.0; extra == 'dev'
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: isort<7.0.0,>=6.0.1; extra == 'dev'
+Requires-Dist: mypy<2.0.0,>=1.15.0; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest<9.0.0,>=8.3.5; extra == 'dev'
+Requires-Dist: ruff<0.12.0,>=0.11.2; extra == 'dev'
+Requires-Dist: types-requests<3.0.0,>=2.28.0; extra == 'dev'
+Requires-Dist: vulture<3.0,>=2.0; extra == 'dev'

excel_dbapi-0.1.0/README.md

@@ -0,0 +1,94 @@
+# excel-dbapi
+
+A DBAPI-like interface for Excel files with extensible engines.
+
+---
+
+## Development Setup
+
+If you're contributing to this project or running it in development mode, follow the steps below.
+
+### 1. Clone the repository
+
+```bash
+git clone https://github.com/your-username/exceldb.git
+cd exceldb
+```
+
+### 2. Create and activate virtual environment
+
+```bash
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+```
+
+### 3. Install dependencies (with dev tools)
+
+```bash
+pip install --upgrade pip setuptools hatchling
+pip install .[dev]
+hatch develop
+```
+
+> 💡 This installs runtime and development dependencies (e.g. `pytest`, `black`, `mypy`, `ruff`, etc.)  
+> and sets up the project in editable mode using Hatch.
+
+---
+
+### 4. Run tests, linters, and formatters
+
+You can use the provided `Makefile` for convenient commands:
+
+```bash
+make test       # Run all tests
+make format     # Auto-format code (black + isort)
+make lint       # Run static analysis (ruff + mypy)
+make sec-check  # Run security check (bandit)
+make dead-code  # Detect unused code (vulture)
+make build      # Build the package
+make clean      # Remove build artifacts
+```
+
+---
+
+### ✅ 5. Pre-commit setup
+
+We use `pre-commit` to ensure consistent code quality before every commit.
+
+#### Install and activate hooks
+
+```bash
+pre-commit install
+```
+
+#### Run checks on all files manually (first time)
+
+```bash
+pre-commit run --all-files
+```
+
+#### Pre-commit will automatically run the following tools:
+- `black`: code formatter
+- `isort`: import sorter
+- `ruff`: code style checker
+- `mypy`: type checker
+- `bandit`: security analyzer
+- `vulture`: unused code detector
+
+---
+
+### 🧹 6. Clean build artifacts
+
+```bash
+make clean
+```
+
+---
+
+### 💡 Notes
+
+- Python 3.9+ is required.
+- We use [Hatchling](https://hatch.pypa.io/latest/) as the build backend.
+- Editable installs are handled with `hatch develop`.
+- Development dependencies are managed via `[project.optional-dependencies].dev` in `pyproject.toml`.
+

excel_dbapi-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "excel-dbapi"
+version = "0.1.0"
+description = "A DBAPI-like interface for Excel files with extensible engines"
+authors = [{ name = "Yeongseon Choe", email = "yeongseon.choe@gmail.com" }]
+requires-python = ">=3.9"
+dependencies = [
+    "openpyxl>=3.1.0",
+    "requests>=2.28.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3.5,<9.0.0",
+    "black>=25.1.0,<26.0.0",
+    "isort>=6.0.1,<7.0.0",
+    "ruff>=0.11.2,<0.12.0",
+    "mypy>=1.15.0,<2.0.0",
+    "build",
+    "bandit>=1.7.0,<2.0.0",
+    "vulture>=2.0,<3.0",
+    "pre-commit",
+    "types-requests>=2.28.0,<3.0.0"
+]
+
+[tool.mypy]
+ignore_missing_imports = true
+strict = false

excel_dbapi-0.1.0/src/excel_dbapi/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

excel_dbapi-0.1.0/src/excel_dbapi/connection.py

@@ -0,0 +1,75 @@
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, Protocol, Union
+
+from openpyxl.workbook.workbook import Workbook
+from openpyxl.worksheet.worksheet import Worksheet
+
+from .engines.openpyxl_engine import OpenPyXLEngine
+from .exceptions import OperationalError
+from .remote import fetch_remote_file
+
+
+class ExcelEngine(Protocol):
+    """Protocol for Excel processing engines."""
+
+    def load_workbook(self, file_path: Union[str, BytesIO]) -> "ExcelEngine": ...
+    def close(self) -> None: ...
+    def get_sheet(self, sheet_name: str) -> Worksheet: ...
+    @property
+    def workbook(self) -> Workbook: ...
+
+
+class ExcelConnection:
+    """DBAPI-compliant connection to an Excel file."""
+
+    def __init__(
+        self, file_path: Union[str, Path], engine: Optional[ExcelEngine] = None
+    ) -> None:
+        """Initialize with file path and optional engine."""
+        self.file_path = Path(file_path)
+        self.engine: ExcelEngine = engine if engine else OpenPyXLEngine()
+        self._connected = False
+
+    def connect(self) -> "ExcelConnection":
+        """Establish connection to the Excel file."""
+        try:
+            if str(self.file_path).startswith(("http://", "https://")):
+                file_data = fetch_remote_file(self.file_path)
+                self.engine.load_workbook(file_data)
+            else:
+                self.engine.load_workbook(str(self.file_path))
+            self._connected = True
+            return self
+        except Exception as e:
+            raise OperationalError(f"Failed to connect to {self.file_path}: {e}")
+
+    def close(self) -> None:
+        """Close the connection."""
+        if self._connected:
+            self.engine.close()
+            self._connected = False
+
+    def commit(self) -> None:
+        """Commit changes (not applicable for read-only Excel, placeholder)."""
+        pass
+
+    def rollback(self) -> None:
+        """Rollback changes (not applicable, placeholder)."""
+        pass
+
+    def cursor(self):  # 타입 주석 제거 및 임포트 지연
+        """Return a new cursor object."""
+        from .cursor import ExcelCursor  # 메서드 안에서 임포트
+
+        if not self._connected:
+            raise OperationalError("Connection is not established.")
+        return ExcelCursor(self)
+
+    def __enter__(self) -> "ExcelConnection":
+        """Context manager entry."""
+        return self.connect()
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit."""
+        self.close()

excel_dbapi-0.1.0/src/excel_dbapi/cursor.py

@@ -0,0 +1,75 @@
+from typing import Dict, List, Optional, Union
+
+from .connection import ExcelConnection
+from .exceptions import OperationalError, ProgrammingError
+from .query import QueryEngine
+from .table import ExcelTable
+
+
+class ExcelCursor:
+    """DBAPI-compliant cursor for executing queries on Excel tables."""
+
+    def __init__(self, connection: ExcelConnection) -> None:
+        """Initialize with a connection."""
+        self.connection = connection
+        self.table: Optional[ExcelTable] = None
+        self._results: Optional[List[Dict[str, Union[str, int, float]]]] = None
+        self._rowcount = -1
+
+    def execute(self, query: str, params: Optional[tuple] = None) -> None:
+        """Execute a SQL-like query."""
+        if not query.strip().upper().startswith("SELECT"):
+            raise ProgrammingError("Only SELECT queries are supported.")
+
+        if "FROM" not in query.upper():
+            raise ProgrammingError("Query must include FROM clause.")
+
+        table_name = query.split("FROM", 1)[1].strip().split()[0]
+        self.table = ExcelTable(self.connection, table_name)
+
+        with self.table:
+            qe = QueryEngine(self.table)
+            if "*" in query:
+                self._results = qe.select()
+            else:
+                columns = [
+                    col.strip()
+                    for col in query.split("SELECT")[1].split("FROM")[0].split(",")
+                ]
+                self._results = qe.select(columns=columns)
+            self._rowcount = len(self._results or [])
+
+    def fetchone(self) -> Optional[Dict[str, Union[str, int, float]]]:
+        """Fetch the next row of the query result."""
+        if self._results is None:
+            raise OperationalError("No query executed.")
+        if not self._results:
+            return None
+        return self._results.pop(0)
+
+    def fetchall(self) -> List[Dict[str, Union[str, int, float]]]:
+        """Fetch all rows of the query result."""
+        if self._results is None:
+            raise OperationalError("No query executed.")
+        results = self._results or []
+        self._results = []
+        return results
+
+    def fetchmany(self, size: int = 1) -> List[Dict[str, Union[str, int, float]]]:
+        """Fetch a specified number of rows."""
+        if self._results is None:
+            raise OperationalError("No query executed.")
+        results = self._results[:size]
+        self._results = self._results[size:]
+        return results
+
+    @property
+    def rowcount(self) -> int:
+        """Return the number of rows affected."""
+        return self._rowcount
+
+    def close(self) -> None:
+        """Close the cursor."""
+        self.table = None
+        self._results = None
+        self._rowcount = -1

excel_dbapi-0.1.0/src/excel_dbapi/engines/openpyxl_engine.py

@@ -0,0 +1,46 @@
+from io import BytesIO
+from typing import Optional, Union
+
+import openpyxl
+from openpyxl.workbook.workbook import Workbook
+from openpyxl.worksheet.worksheet import Worksheet
+
+from ..exceptions import OperationalError
+
+
+class OpenPyXLEngine:
+    """Excel processing engine using openpyxl."""
+
+    def __init__(self) -> None:
+        """Initialize the engine."""
+        self._workbook: Optional[Workbook] = None
+
+    def load_workbook(self, file_path: Union[str, BytesIO]) -> "OpenPyXLEngine":
+        """Load the workbook from a file path or BytesIO."""
+        try:
+            self._workbook = openpyxl.load_workbook(file_path)
+            return self
+        except Exception as e:
+            raise OperationalError(f"Failed to load workbook: {e}")
+
+    def close(self) -> None:
+        """Close the workbook."""
+        if self._workbook:
+            self._workbook.close()
+            self._workbook = None
+
+    def get_sheet(self, sheet_name: str) -> Worksheet:
+        """Get a specific sheet by name."""
+        if not self._workbook:
+            raise OperationalError("Workbook not loaded.")
+        try:
+            return self._workbook[sheet_name]
+        except KeyError:
+            raise OperationalError(f"Sheet '{sheet_name}' not found.")
+
+    @property
+    def workbook(self) -> Workbook:
+        """Property to access the loaded workbook."""
+        if not self._workbook:
+            raise OperationalError("Workbook not loaded.")
+        return self._workbook

excel_dbapi-0.1.0/src/excel_dbapi/exceptions.py

@@ -0,0 +1,34 @@
+class Error(Exception):
+    """Base class for all DBAPI exceptions."""
+
+    pass
+
+
+class InterfaceError(Error):
+    """Raised for errors related to the database interface."""
+
+    pass
+
+
+class DatabaseError(Error):
+    """Raised for errors related to the database itself."""
+
+    pass
+
+
+class TableError(Exception):
+    """Raised when a table-related error occurs."""
+
+    pass
+
+
+class OperationalError(DatabaseError):
+    """Raised for operational errors (e.g., connection issues)."""
+
+    pass
+
+
+class ProgrammingError(DatabaseError):
+    """Raised for programming errors (e.g., invalid SQL)."""
+
+    pass

excel_dbapi-0.1.0/src/excel_dbapi/query.py

@@ -0,0 +1,54 @@
+from typing import Callable, Dict, List, Optional, Union
+
+from .exceptions import OperationalError
+from .table import ExcelTable
+
+
+class QueryEngine:
+    """Engine for executing SQL-like queries on Excel tables."""
+
+    def __init__(self, table: ExcelTable) -> None:
+        """Initialize with a table instance."""
+        self.table = table
+
+    def select(
+        self,
+        columns: Optional[List[str]] = None,
+        where: Optional[Callable[[List[Union[str, int, float]]], bool]] = None,
+        limit: Optional[int] = None,
+    ) -> List[Dict[str, Union[str, int, float]]]:
+        """Execute a SELECT query with optional columns, where clause, and limit."""
+        if not self.table.sheet:
+            raise OperationalError("Table must be opened before querying.")
+
+        headers = [cell.value for cell in self.table.sheet[1]]
+        if not headers or not all(isinstance(h, str) for h in headers):
+            raise OperationalError("First row must contain valid string headers.")
+
+        if columns:
+            col_indices = [headers.index(col) for col in columns if col in headers]
+        else:
+            col_indices = list(range(len(headers)))
+
+        rows = self.table.fetch_all()[1:]
+        result: List[Dict[str, Union[str, int, float]]] = []
+
+        for row in rows:
+            if where is None or where(row):
+                row_dict = {headers[i]: row[i] for i in col_indices}
+                result.append(row_dict)
+                if limit and len(result) >= limit:
+                    break
+
+        return result
+
+
+def query(
+    table: ExcelTable,
+    columns: Optional[List[str]] = None,
+    where: Optional[Callable[[List[Union[str, int, float]]], bool]] = None,
+    limit: Optional[int] = None,
+) -> List[Dict[str, Union[str, int, float]]]:
+    """Convenience function to execute a query."""
+    engine = QueryEngine(table)
+    return engine.select(columns=columns, where=where, limit=limit)

excel_dbapi-0.1.0/src/excel_dbapi/remote.py

@@ -0,0 +1,17 @@
+from io import BytesIO
+from pathlib import Path
+from typing import Union
+
+import requests
+
+from .exceptions import OperationalError  # ConnectionError -> OperationalError
+
+
+def fetch_remote_file(url: Union[str, Path]) -> BytesIO:
+    """Fetch a remote file and return it as BytesIO."""
+    try:
+        response = requests.get(str(url), timeout=10)
+        response.raise_for_status()
+        return BytesIO(response.content)
+    except requests.RequestException as e:
+        raise OperationalError(f"Failed to fetch remote file {url}: {e}")

excel_dbapi-0.1.0/src/excel_dbapi/table.py

@@ -0,0 +1,53 @@
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from .connection import ExcelConnection
+from .exceptions import OperationalError
+
+
+class ExcelTable:
+    """Class to treat an Excel sheet as a table."""
+
+    def __init__(self, connection: ExcelConnection, sheet_name: str) -> None:
+        """Initialize with a connection and sheet name."""
+        self.connection = connection
+        self.sheet_name = sheet_name
+        self.sheet: Optional[Any] = None
+
+    def open(self) -> "ExcelTable":
+        """Open the sheet and prepare it as a table."""
+        try:
+            self.sheet = self.connection.engine.get_sheet(self.sheet_name)
+            return self
+        except Exception as e:
+            raise OperationalError(f"Failed to open sheet '{self.sheet_name}': {e}")
+
+    def fetch_all(self) -> List[List[Union[str, int, float]]]:
+        """Fetch all data from the sheet."""
+        if not self.sheet:
+            raise OperationalError("Table is not opened.")
+        return [[cell.value for cell in row] for row in self.sheet.rows]
+
+    def fetch_row(self, row_num: int) -> List[Union[str, int, float]]:
+        """Fetch a specific row by number (1-based index)."""
+        if not self.sheet:
+            raise OperationalError("Table is not opened.")
+        return [cell.value for cell in self.sheet[row_num]]
+
+    def query(
+        self,
+        columns: Optional[List[str]] = None,
+        where: Optional[Callable[[List[Union[str, int, float]]], bool]] = None,
+        limit: Optional[int] = None,
+    ) -> List[Dict[str, Union[str, int, float]]]:
+        """Execute a query on the table."""
+        from .query import query  # lazy import to avoid circular dependency
+
+        return query(self, columns=columns, where=where, limit=limit)
+
+    def __enter__(self) -> "ExcelTable":
+        """Context manager entry."""
+        return self.open()
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit."""
+        self.sheet = None

excel_dbapi-0.1.0/tests/test_connection.py

@@ -0,0 +1,24 @@
+import pytest
+
+from excel_dbapi.connection import ExcelConnection
+from excel_dbapi.exceptions import OperationalError
+
+
+def test_connection_local(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        assert conn.engine.workbook is not None
+
+    with pytest.raises(OperationalError):
+        _ = conn.engine.workbook
+
+
+def test_connection_invalid_file():
+    with pytest.raises(OperationalError):
+        with ExcelConnection("nonexistent.xlsx"):
+            pass

excel_dbapi-0.1.0/tests/test_cursor.py

@@ -0,0 +1,54 @@
+import pytest
+
+from excel_dbapi.connection import ExcelConnection
+from excel_dbapi.exceptions import ProgrammingError
+
+
+def test_cursor_execute_fetchall(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    ws = wb.active
+    ws.append(["Name", "Age"])
+    ws.append(["Alice", 25])
+    ws.append(["Bob", 30])
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM Sheet")
+        result = cursor.fetchall()
+        assert result == [{"Name": "Alice", "Age": 25}, {"Name": "Bob", "Age": 30}]
+        assert cursor.rowcount == 2
+
+
+def test_cursor_fetchone(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    ws = wb.active
+    ws.append(["Name", "Age"])
+    ws.append(["Alice", 25])
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM Sheet")
+        row = cursor.fetchone()
+        assert row == {"Name": "Alice", "Age": 25}
+        assert cursor.fetchone() is None
+
+
+def test_cursor_invalid_query(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        cursor = conn.cursor()
+        with pytest.raises(ProgrammingError):
+            cursor.execute("INSERT INTO Sheet")

excel_dbapi-0.1.0/tests/test_query.py

@@ -0,0 +1,72 @@
+from excel_dbapi.connection import ExcelConnection
+from excel_dbapi.table import ExcelTable
+
+
+def test_query_all(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    ws = wb.active
+    ws.append(["Name", "Age", "City"])
+    ws.append(["Alice", 25, "Seoul"])
+    ws.append(["Bob", 30, "Tokyo"])
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        with ExcelTable(conn, "Sheet") as table:
+            result = table.query()
+            assert result == [
+                {"Name": "Alice", "Age": 25, "City": "Seoul"},
+                {"Name": "Bob", "Age": 30, "City": "Tokyo"},
+            ]
+
+
+def test_query_columns(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    ws = wb.active
+    ws.append(["Name", "Age", "City"])
+    ws.append(["Alice", 25, "Seoul"])
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        with ExcelTable(conn, "Sheet") as table:
+            result = table.query(columns=["Name"])
+            assert result == [{"Name": "Alice"}]
+
+
+def test_query_where(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    ws = wb.active
+    ws.append(["Name", "Age", "City"])
+    ws.append(["Alice", 25, "Seoul"])
+    ws.append(["Bob", 30, "Tokyo"])
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        with ExcelTable(conn, "Sheet") as table:
+            result = table.query(where=lambda row: row[1] > 25)
+            assert result == [{"Name": "Bob", "Age": 30, "City": "Tokyo"}]
+
+
+def test_query_limit(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    ws = wb.active
+    ws.append(["Name", "Age"])
+    ws.append(["Alice", 25])
+    ws.append(["Bob", 30])
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        with ExcelTable(conn, "Sheet") as table:
+            result = table.query(limit=1)
+            assert result == [{"Name": "Alice", "Age": 25}]

excel_dbapi-0.1.0/tests/test_table.py

@@ -0,0 +1,51 @@
+import pytest
+
+from excel_dbapi.connection import ExcelConnection
+from excel_dbapi.exceptions import OperationalError
+from excel_dbapi.table import ExcelTable
+
+
+def test_table_fetch_all(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    ws = wb.active
+    ws.append(["Name", "Age"])
+    ws.append(["Alice", 25])
+    ws.append(["Bob", 30])
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        with ExcelTable(conn, "Sheet") as table:
+            data = table.fetch_all()
+            assert data == [["Name", "Age"], ["Alice", 25], ["Bob", 30]]
+
+
+def test_table_fetch_row(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    ws = wb.active
+    ws.append(["Name", "Age"])
+    ws.append(["Alice", 25])
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        with ExcelTable(conn, "Sheet") as table:
+            row = table.fetch_row(2)
+            assert row == ["Alice", 25]
+
+
+def test_table_invalid_sheet(tmp_path):
+    from openpyxl import Workbook
+
+    file_path = tmp_path / "test.xlsx"
+    wb = Workbook()
+    wb.save(file_path)
+
+    with ExcelConnection(file_path) as conn:
+        with pytest.raises(OperationalError):
+            with ExcelTable(conn, "Nonexistent"):
+                pass