sqlalchemy-excel 0.1.1__py3-none-any.whl

sqlalchemy_excel/__init__.py

@@ -0,0 +1,12 @@
+"""sqlalchemy-excel — SQLAlchemy dialect for Excel files."""
+
+from __future__ import annotations
+
+from .dialect import ExcelDialect
+
+__version__ = "0.1.1"
+
+__all__ = [
+    "ExcelDialect",
+    "__version__",
+]

sqlalchemy_excel/compiler.py

@@ -0,0 +1,159 @@
+"""SQL compiler for the Excel dialect.
+
+Compiles SQLAlchemy expression trees into the SQL subset that
+excel-dbapi's parser understands:
+
+Supported:
+    SELECT columns FROM table [WHERE ...] [ORDER BY col [ASC|DESC]] [LIMIT n]
+    INSERT INTO table (cols) VALUES (vals)
+    UPDATE table SET col=val [WHERE ...]
+    DELETE FROM table [WHERE ...]
+
+Rejected (raises CompileError):
+    JOIN, GROUP BY, HAVING, DISTINCT, OFFSET, subqueries,
+    CTEs, aggregate functions, window functions, RETURNING
+
+excel-dbapi's parser uses unquoted, unprefixed column names:
+    SELECT id, name FROM users          (correct)
+    SELECT users.id, users.name FROM users  (WRONG — parser rejects)
+
+So we override the identifier preparer to never use table prefixes.
+"""
+
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+from sqlalchemy import exc
+from sqlalchemy.sql import compiler, elements
+
+
+class ExcelIdentifierPreparer(compiler.IdentifierPreparer):
+    """Identifier preparer that never quotes identifiers.
+
+    excel-dbapi's parser expects bare column names without quotes
+    or table prefixes.
+    """
+
+    reserved_words: ClassVar[set[str]] = set()
+
+    def __init__(self, dialect: Any) -> None:
+        super().__init__(dialect, initial_quote="", final_quote="")
+
+    def quote_identifier(self, value: str) -> str:
+        return value
+
+    def quote(self, ident: str, force: Any = None) -> str:
+        return ident
+
+
+class ExcelCompiler(compiler.SQLCompiler):
+    """Compiles SQLAlchemy SQL expressions for excel-dbapi."""
+
+    def visit_column(
+        self,
+        column: Any,
+        add_to_result_map: Any = None,
+        include_table: bool = True,
+        **kw: Any,
+    ) -> str:
+        """Override to never include table prefix in column references.
+
+        excel-dbapi expects: SELECT id, name FROM users
+        Not: SELECT users.id, users.name FROM users
+        """
+        # Force include_table=False to avoid table.column notation
+        return super().visit_column(
+            column,
+            add_to_result_map=add_to_result_map,
+            include_table=False,
+            **kw,
+        )
+
+    def visit_label(
+        self,
+        label: Any,
+        add_to_result_map: Any = None,
+        within_label_clause: bool = False,
+        within_columns_clause: bool = False,
+        render_label_as_label: Any = None,
+        result_map_targets: Any = (),
+        **kw: Any,
+    ) -> str:
+        """Override to never emit AS <label> in SELECT columns.
+
+        excel-dbapi's parser does not understand column aliases.
+        We still register the result map so SQLAlchemy can map
+        result columns back to ORM attributes by position.
+        """
+        render_label_with_as = within_columns_clause and not within_label_clause
+
+        if render_label_with_as:
+            # Compute the label name for the result map
+            if isinstance(label.name, elements._truncated_label):
+                labelname = self._truncated_identifier("colident", label.name)
+            else:
+                labelname = label.name
+
+            if add_to_result_map is not None:
+                add_to_result_map(
+                    labelname,
+                    label.name,
+                    (label, labelname) + label._alt_names + result_map_targets,
+                    label.type,
+                )
+
+            # Emit the column WITHOUT "AS <label>"
+            return label.element._compiler_dispatch(
+                self,
+                within_columns_clause=True,
+                within_label_clause=True,
+                **kw,
+            )
+
+        if render_label_as_label is label:
+            if isinstance(label.name, elements._truncated_label):
+                labelname = self._truncated_identifier("colident", label.name)
+            else:
+                labelname = label.name
+            return self.preparer.format_label(label, labelname)
+
+        return label.element._compiler_dispatch(self, within_columns_clause=False, **kw)
+
+    # ── Unsupported feature guards ─────────────────────────
+
+    def visit_join(self, join: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support JOIN")
+
+    def group_by_clause(self, select: Any, **kw: Any) -> str:
+        if select._group_by_clauses:
+            raise exc.CompileError("Excel dialect does not support GROUP BY")
+        return ""
+
+    def having_clause(self, select: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support HAVING")
+
+    def limit_clause(self, select: Any, **kw: Any) -> str:
+        text = ""
+        if select._limit_clause is not None:
+            text += " LIMIT " + self.process(select._limit_clause, **kw)
+        if select._offset_clause is not None:
+            raise exc.CompileError("Excel dialect does not support OFFSET")
+        return text
+
+    def visit_cte(self, cte: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support CTEs")
+
+    def visit_subquery(self, subquery: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support subqueries")
+
+    def returning_clause(
+        self,
+        stmt: Any,
+        returning_cols: Any,
+        **kw: Any,
+    ) -> str:
+        raise exc.CompileError("Excel dialect does not support RETURNING")
+
+    def for_update_clause(self, select: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support SELECT ... FOR UPDATE")

sqlalchemy_excel/ddl.py

@@ -0,0 +1,57 @@
+"""DDL compiler for the Excel dialect.
+
+CREATE TABLE → creates a worksheet and writes column metadata.
+DROP TABLE   → deletes the worksheet and removes metadata.
+ALTER TABLE  → rejected (not supported).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import exc
+from sqlalchemy.sql import compiler
+
+
+class ExcelDDLCompiler(compiler.DDLCompiler):
+    """Compiles DDL statements for excel-dbapi."""
+
+    def visit_create_table(self, create: Any, **kw: Any) -> str:
+        """Compile CREATE TABLE into SQL that excel-dbapi's parser accepts.
+
+        Format: CREATE TABLE name (col1 TYPE, col2 TYPE, ...)
+        """
+        table = create.element
+        table_name = self.preparer.format_table(table)
+
+        columns = []
+        for col in table.columns:
+            col_name = self.preparer.format_column(col)
+            col_type = self.dialect.type_compiler.process(col.type)
+            columns.append(f"{col_name} {col_type}")
+
+        return f"CREATE TABLE {table_name} ({', '.join(columns)})"
+
+    def visit_drop_table(self, drop: Any, **kw: Any) -> str:
+        """Compile DROP TABLE."""
+        table = drop.element
+        table_name = self.preparer.format_table(table)
+        return f"DROP TABLE {table_name}"
+
+    def visit_create_index(self, create: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support CREATE INDEX")
+
+    def visit_drop_index(self, drop: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support DROP INDEX")
+
+    def visit_add_constraint(self, create: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support constraints")
+
+    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:
+        raise exc.CompileError("Excel dialect does not support sequences")
+
+    def visit_drop_sequence(self, drop: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support sequences")

sqlalchemy_excel/dialect.py

@@ -0,0 +1,221 @@
+"""ExcelDialect — SQLAlchemy dialect that uses excel-dbapi as the DB-API driver."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from sqlalchemy import event, pool
+from sqlalchemy.engine import default
+from sqlalchemy.schema import Table
+
+from .compiler import ExcelCompiler, ExcelIdentifierPreparer
+from .ddl import ExcelDDLCompiler
+from .reflection import ExcelInspectionMixin
+from .types import ExcelTypeCompiler
+
+if TYPE_CHECKING:
+    from sqlalchemy.engine import URL
+    from sqlalchemy.engine.interfaces import ConnectArgsType
+
+
+def _after_create(
+    target: Table,
+    connection: Any,
+    **kw: Any,
+) -> None:
+    """Write column metadata after CREATE TABLE (Excel dialect only)."""
+    if connection.dialect.name != "excel":
+        return
+    import excel_dbapi
+
+    raw_conn = connection.connection.dbapi_connection
+    pk_cols = {col.name for col in target.primary_key.columns}
+
+    columns = []
+    for col in target.columns:
+        type_compiler = connection.dialect.type_compiler
+        type_name = type_compiler.process(col.type)
+        columns.append(
+            {
+                "name": col.name,
+                "type_name": type_name,
+                "nullable": col.nullable if col.nullable is not None else True,
+                "primary_key": col.name in pk_cols,
+            }
+        )
+
+    excel_dbapi.write_table_metadata(raw_conn, target.name, columns)
+
+
+def _after_drop(
+    target: Table,
+    connection: Any,
+    **kw: Any,
+) -> None:
+    """Remove column metadata after DROP TABLE (Excel dialect only)."""
+    if connection.dialect.name != "excel":
+        return
+    import excel_dbapi
+
+    raw_conn = connection.connection.dbapi_connection
+    excel_dbapi.remove_table_metadata(raw_conn, target.name)
+
+
+# Register DDL events globally for all Table objects
+event.listen(Table, "after_create", _after_create)
+event.listen(Table, "after_drop", _after_drop)
+
+
+class ExcelDialect(ExcelInspectionMixin, default.DefaultDialect):  # type: ignore[misc]
+    """SQLAlchemy dialect for Excel files via excel-dbapi.
+
+    Connection URLs::
+
+        # Relative path
+        excel:///data.xlsx
+
+        # Absolute path
+        excel:////home/user/data.xlsx
+        excel:///C:/Users/data.xlsx  (Windows)
+
+    """
+
+    name: ClassVar[str] = "excel"
+    driver: ClassVar[str] = "dbapi"
+    default_paramstyle: ClassVar[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
+
+    # ── Compiler classes ──────────────────────────────────
+    statement_compiler = ExcelCompiler
+    ddl_compiler = ExcelDDLCompiler
+    type_compiler_cls = ExcelTypeCompiler
+    preparer = ExcelIdentifierPreparer
+
+    @classmethod
+    def import_dbapi(cls) -> Any:
+        import excel_dbapi
+
+        return excel_dbapi
+
+    @classmethod
+    def get_pool_class(cls, url: URL) -> type[pool.Pool]:
+        return pool.StaticPool
+
+    def create_connect_args(self, url: URL) -> ConnectArgsType:
+        """Translate a SQLAlchemy URL to excel-dbapi connect() arguments.
+
+        URL formats:
+            excel:///relative/path.xlsx   →  file_path="relative/path.xlsx"
+            excel:////absolute/path.xlsx  →  file_path="/absolute/path.xlsx"
+        """
+        # url.database contains the path after the third slash
+        file_path = url.database
+        if not file_path:
+            raise ValueError("No file path in URL. Use excel:///path/to/file.xlsx")
+
+        kwargs: dict[str, Any] = {
+            "file_path": file_path,
+            "engine": "openpyxl",
+            "autocommit": False,
+            "create": True,
+        }
+
+        # Forward query parameters
+        query = dict(url.query)
+        if "engine" in query:
+            kwargs["engine"] = query.pop("engine")
+        if "autocommit" in query:
+            kwargs["autocommit"] = query.pop("autocommit").lower() in (
+                "true",
+                "1",
+                "yes",
+            )
+
+        return ([], kwargs)
+
+    def on_connect(self) -> None:
+        """No-op: no special connection initialization needed."""
+
+    def do_execute(
+        self,
+        cursor: Any,
+        statement: str,
+        parameters: Any,
+        context: Any = None,
+    ) -> None:
+        """Execute a statement, normalizing whitespace for excel-dbapi."""
+        normalized = re.sub(r"\s+", " ", statement).strip()
+        cursor.execute(normalized, parameters)
+
+    def do_execute_no_params(
+        self,
+        cursor: Any,
+        statement: str,
+        context: Any = None,
+    ) -> None:
+        """Execute a statement with no parameters."""
+        normalized = re.sub(r"\s+", " ", statement).strip()
+        cursor.execute(normalized, None)
+
+    def do_ping(self, dbapi_connection: Any) -> bool:
+        """Ping the connection by verifying it's not closed."""
+        return not getattr(dbapi_connection, "closed", True)
+
+    def is_disconnect(self, e: Exception, connection: Any, cursor: Any) -> bool:
+        """Excel connections don't have network-level disconnects."""
+        return False
+
+    def get_default_isolation_level(self, dbapi_conn: Any) -> str:
+        return "SERIALIZABLE"
+
+    def _check_unicode_returns(
+        self, connection: Any, additional_tests: Any = None
+    ) -> bool:
+        return True
+
+    def _check_unicode_description(self, connection: Any) -> bool:
+        return True
+
+    def has_table(
+        self,
+        connection: Any,
+        table_name: str,
+        schema: str | None = None,
+        **kw: Any,
+    ) -> bool:
+        """Check if a worksheet (table) exists."""
+        import excel_dbapi
+
+        raw_conn = connection.connection.dbapi_connection
+        return 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."""
+
+    def do_commit(self, dbapi_connection: Any) -> None:
+        """Commit (save) the workbook."""
+        dbapi_connection.commit()
+
+    def do_rollback(self, dbapi_connection: Any) -> None:
+        """Rollback is not supported with autocommit=False in a meaningful way
+        for Excel files. We silently ignore it to avoid crashes during
+        connection pool cleanup."""
+
+    def do_close(self, dbapi_connection: Any) -> None:
+        """Close the underlying excel-dbapi connection."""
+        dbapi_connection.close()

sqlalchemy_excel/reflection.py

@@ -0,0 +1,173 @@
+"""Reflection (introspection) support for the Excel dialect.
+
+Provides the Inspector integration so that SQLAlchemy can discover
+tables (worksheets), columns, and primary keys from an Excel file.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import types as sa_types
+
+_TYPE_MAP: dict[str, type[sa_types.TypeEngine]] = {
+    "TEXT": sa_types.String,
+    "INTEGER": sa_types.Integer,
+    "FLOAT": sa_types.Float,
+    "BOOLEAN": sa_types.Boolean,
+    "DATE": sa_types.Date,
+    "DATETIME": sa_types.DateTime,
+}
+
+
+def _sa_type_from_name(type_name: str) -> sa_types.TypeEngine:
+    """Convert an excel-dbapi type name to a SQLAlchemy type instance."""
+    cls = _TYPE_MAP.get(type_name.upper(), sa_types.String)
+    return cls()
+
+
+class ExcelInspectionMixin:
+    """Mixin that provides reflection methods for ExcelDialect.
+
+    These methods are called by SQLAlchemy's Inspector to discover
+    the structure of an Excel workbook.
+    """
+
+    def get_table_names(
+        self,
+        connection: Any,
+        schema: str | None = None,
+        **kw: Any,
+    ) -> list[str]:
+        """Return all worksheet names, excluding the metadata sheet."""
+        import excel_dbapi
+
+        raw_conn = connection.connection.dbapi_connection
+        return excel_dbapi.list_tables(raw_conn, include_meta=False)
+
+    def get_view_names(
+        self,
+        connection: Any,
+        schema: str | None = None,
+        **kw: Any,
+    ) -> list[str]:
+        """Excel does not support views."""
+        return []
+
+    def get_columns(
+        self,
+        connection: Any,
+        table_name: str,
+        schema: str | None = None,
+        **kw: Any,
+    ) -> list[dict[str, Any]]:
+        """Return column information for the given table (worksheet).
+
+        First tries to read from the metadata sheet (written by CREATE TABLE).
+        Falls back to type inference from data sampling.
+        """
+        import excel_dbapi
+
+        raw_conn = connection.connection.dbapi_connection
+
+        # Try metadata sheet first
+        meta = excel_dbapi.read_table_metadata(raw_conn, table_name)
+        if meta is not None:
+            return [
+                {
+                    "name": col["name"],
+                    "type": _sa_type_from_name(col["type_name"]),
+                    "nullable": col.get("nullable", True),
+                    "default": None,
+                    "autoincrement": False,
+                    "comment": None,
+                }
+                for col in meta
+            ]
+
+        # Fallback: infer from data
+        inferred = excel_dbapi.get_columns(raw_conn, table_name)
+        return [
+            {
+                "name": col["name"],
+                "type": _sa_type_from_name(col["type"]),
+                "nullable": col.get("nullable", True),
+                "default": None,
+                "autoincrement": False,
+                "comment": None,
+            }
+            for col in inferred
+        ]
+
+    def get_pk_constraint(
+        self,
+        connection: Any,
+        table_name: str,
+        schema: str | None = None,
+        **kw: Any,
+    ) -> dict[str, Any]:
+        """Return primary key constraint info from the metadata sheet."""
+        import excel_dbapi
+
+        raw_conn = connection.connection.dbapi_connection
+        meta = excel_dbapi.read_table_metadata(raw_conn, table_name)
+        if meta is not None:
+            pk_cols = [col["name"] for col in meta if col.get("primary_key", False)]
+            if pk_cols:
+                return {"constrained_columns": pk_cols, "name": None}
+
+        return {"constrained_columns": [], "name": None}
+
+    def get_foreign_keys(
+        self,
+        connection: Any,
+        table_name: str,
+        schema: str | None = None,
+        **kw: Any,
+    ) -> list[dict[str, Any]]:
+        """Excel does not support foreign keys."""
+        return []
+
+    def get_indexes(
+        self,
+        connection: Any,
+        table_name: str,
+        schema: str | None = None,
+        **kw: Any,
+    ) -> list[dict[str, Any]]:
+        """Excel does not support indexes."""
+        return []
+
+    def get_unique_constraints(
+        self,
+        connection: Any,
+        table_name: str,
+        schema: str | None = None,
+        **kw: Any,
+    ) -> list[dict[str, Any]]:
+        """Excel does not support unique constraints."""
+        return []
+
+    def get_check_constraints(
+        self,
+        connection: Any,
+        table_name: str,
+        schema: str | None = None,
+        **kw: Any,
+    ) -> list[dict[str, Any]]:
+        """Excel does not support check constraints."""
+        return []
+
+    def get_table_comment(
+        self,
+        connection: Any,
+        table_name: str,
+        schema: str | None = None,
+        **kw: Any,
+    ) -> dict[str, Any]:
+        """Excel does not support table comments."""
+        return {"text": None}
+
+    def get_schema_names(self, connection: Any, **kw: Any) -> list[str]:
+        """Excel does not support schemas."""
+        return []

sqlalchemy_excel/types.py

@@ -0,0 +1,100 @@
+"""Type compiler for the Excel dialect.
+
+Maps SQLAlchemy types to the type names that excel-dbapi understands:
+    TEXT, INTEGER, FLOAT, BOOLEAN, DATE, DATETIME
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import exc
+from sqlalchemy.sql import compiler
+
+
+class ExcelTypeCompiler(compiler.GenericTypeCompiler):
+    """Maps SQLAlchemy column types to Excel-compatible type strings."""
+
+    def visit_STRING(self, type_: Any, **kw: Any) -> str:
+        return "TEXT"
+
+    def visit_TEXT(self, type_: Any, **kw: Any) -> str:
+        return "TEXT"
+
+    def visit_NVARCHAR(self, type_: Any, **kw: Any) -> str:
+        return "TEXT"
+
+    def visit_VARCHAR(self, type_: Any, **kw: Any) -> str:
+        return "TEXT"
+
+    def visit_CHAR(self, type_: Any, **kw: Any) -> str:
+        return "TEXT"
+
+    def visit_NCHAR(self, type_: Any, **kw: Any) -> str:
+        return "TEXT"
+
+    def visit_CLOB(self, type_: Any, **kw: Any) -> str:
+        return "TEXT"
+
+    def visit_INTEGER(self, type_: Any, **kw: Any) -> str:
+        return "INTEGER"
+
+    def visit_SMALLINT(self, type_: Any, **kw: Any) -> str:
+        return "INTEGER"
+
+    def visit_BIGINT(self, type_: Any, **kw: Any) -> str:
+        return "INTEGER"
+
+    def visit_FLOAT(self, type_: Any, **kw: Any) -> str:
+        return "FLOAT"
+
+    def visit_REAL(self, type_: Any, **kw: Any) -> str:
+        return "FLOAT"
+
+    def visit_DOUBLE(self, type_: Any, **kw: Any) -> str:
+        return "FLOAT"
+
+    def visit_DOUBLE_PRECISION(self, type_: Any, **kw: Any) -> str:
+        return "FLOAT"
+
+    def visit_NUMERIC(self, type_: Any, **kw: Any) -> str:
+        return "FLOAT"
+
+    def visit_DECIMAL(self, type_: Any, **kw: Any) -> str:
+        return "FLOAT"
+
+    def visit_BOOLEAN(self, type_: Any, **kw: Any) -> str:
+        return "BOOLEAN"
+
+    def visit_DATE(self, type_: Any, **kw: Any) -> str:
+        return "DATE"
+
+    def visit_DATETIME(self, type_: Any, **kw: Any) -> str:
+        return "DATETIME"
+
+    def visit_TIMESTAMP(self, type_: Any, **kw: Any) -> str:
+        return "DATETIME"
+
+    def visit_TIME(self, type_: Any, **kw: Any) -> str:
+        return "TEXT"
+
+    def visit_BLOB(self, type_: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support BLOB type")
+
+    def visit_BINARY(self, type_: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support BINARY type")
+
+    def visit_VARBINARY(self, type_: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support VARBINARY type")
+
+    def visit_JSON(self, type_: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support JSON type")
+
+    def visit_ARRAY(self, type_: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support ARRAY type")
+
+    def visit_large_binary(self, type_: Any, **kw: Any) -> str:
+        raise exc.CompileError("Excel dialect does not support LargeBinary type")
+
+    def visit_uuid(self, type_: Any, **kw: Any) -> str:
+        return "TEXT"

sqlalchemy_excel-0.1.1.dist-info/METADATA

@@ -0,0 +1,96 @@
+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.dist-info/RECORD

@@ -0,0 +1,11 @@
+sqlalchemy_excel/__init__.py,sha256=EmKZ04CUp9__0xiVTtpvNfAsAnYwuDsmgrSqDn9xBVg,211
+sqlalchemy_excel/compiler.py,sha256=UIb3C-m6iEDMxiuNvjzoKGJc_x7dBnFar4pD04FpciY,5511
+sqlalchemy_excel/ddl.py,sha256=7t-huNzOvCtsYL71DWvC3bnT_ufOKgq_U6HsL-wTFWA,2117
+sqlalchemy_excel/dialect.py,sha256=F5u0Eqi4XFXAX-d-OfaznSIIgwjKM3zUdoFe_crWBRs,7174
+sqlalchemy_excel/reflection.py,sha256=JO9qS7uzwXabtScRB9XObLxs6X8K1rCCNmGWBl2GdVI,5026
+sqlalchemy_excel/types.py,sha256=FnnhRuxKhBamQxmvyZFuiYzE-gQd_1LGkIDfpnL0Yko,3058
+sqlalchemy_excel-0.1.1.dist-info/METADATA,sha256=UrMik9qyZJzQygxz3IPAr2xWc9wBHfR_JCCAMJrcxUw,2734
+sqlalchemy_excel-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sqlalchemy_excel-0.1.1.dist-info/entry_points.txt,sha256=Bl0Hy4J_V012f3oe-WPevI-KE5rVyaqMi_zYBiCIjkE,68
+sqlalchemy_excel-0.1.1.dist-info/licenses/LICENSE,sha256=gBTzk1NFKuyZKqa5-8leVY816k7POZUMpw2_PKl2MsY,1071
+sqlalchemy_excel-0.1.1.dist-info/RECORD,,

sqlalchemy_excel-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sqlalchemy_excel-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[sqlalchemy.dialects]
+excel = sqlalchemy_excel.dialect:ExcelDialect

sqlalchemy_excel-0.1.1.dist-info/licenses/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.