fix: close oracle round 8 DDL and reflection gaps

Author: yeongseon

README.md

@@ -44,7 +44,7 @@ Before writing any code, understand the dialect's capabilities and limits:
 | **ALTER TABLE** | ✅ (ADD/DROP/RENAME COLUMN) |
 | Raw DDL metadata sync (`text()` / `exec_driver_sql()`) | ✅ (`CREATE TABLE` / `ALTER TABLE` / `DROP TABLE`) |
 | **Foreign keys / indexes** | ❌ |
-| **UNIQUE / CHECK enforcement** | ❌ (accepted for compatibility; warnings are emitted) |
+| **UNIQUE / CHECK enforcement** | ❌ (accepted for compatibility; compile-time warnings are emitted for CREATE TABLE and ALTER TABLE ADD COLUMN) |
 | **Concurrent writes** | ❌ |
 | **Session.rollback()** | Partial (openpyxl with autocommit=False; graph: no-op) |
 
@@ -252,8 +252,11 @@ If metadata remains for a deleted worksheet, sqlalchemy-excel removes the stale
 entry and returns an empty inspection result 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`, so declared types
-round-trip through reflection.
+for `CREATE TABLE`, `ALTER TABLE`, and `DROP TABLE`.
+
+- Primary keys declared inline or as table-level composite constraints are reflected.
+- Numeric declarations `FLOAT`, `REAL`, `DECIMAL`, `NUMERIC`, `DOUBLE`, and
+  `DOUBLE PRECISION` are reflected as SQLAlchemy `Float`.
 
 ```python
 from sqlalchemy import create_engine, inspect

docs/USAGE.md

@@ -302,6 +302,9 @@ SQLAlchemy's inspector API works with Excel files:
 - Stale metadata for deleted worksheets is automatically cleaned up.
 - Raw DDL via `text()` / `exec_driver_sql()` keeps metadata synchronized for
   `CREATE TABLE`, `ALTER TABLE`, and `DROP TABLE`.
+- Table-level composite `PRIMARY KEY (...)` declarations are reflected.
+- Raw numeric declarations `FLOAT`, `REAL`, `DECIMAL`, `NUMERIC`, `DOUBLE`,
+  and `DOUBLE PRECISION` are reflected as SQLAlchemy `Float`.
 
 ```python
 from sqlalchemy import create_engine, inspect
@@ -331,7 +334,7 @@ sqlalchemy-excel maps SQLAlchemy types to Excel storage types:
 |-----------------|---------------|-------|
 | `String`, `Text`, `VARCHAR`, `CHAR` | TEXT | All string types → TEXT |
 | `Integer`, `SmallInteger`, `BigInteger` | INTEGER | All integer types → INTEGER |
-| `Float`, `Numeric`, `Decimal` | FLOAT | All numeric types → FLOAT |
+| `Float`, `Numeric`, `Decimal`, `DOUBLE`, `DOUBLE PRECISION` | FLOAT | Reflected as SQLAlchemy `Float` |
 | `Boolean` | BOOLEAN | Stored as boolean |
 | `Date` | DATE | Date without time |
 | `DateTime`, `TIMESTAMP` | DATETIME | Date with time |
@@ -353,7 +356,7 @@ sqlalchemy-excel has some limitations due to the nature of Excel as a database:
 - **ORM relationship limits**: Lazy one-to-many relationship loading can return empty collections; use eager loading (`joinedload`) for reliable one-to-many reads.
 - **Many-to-many loading is unsupported**: Association table persistence works, but relationship loader SQL for many-to-many is not fully supported.
 - **No foreign keys or indexes**: Excel has no concept of these.
-- **UNIQUE/CHECK are not enforced**: They are accepted for SQLAlchemy compatibility, ignored by the backend, and compile-time warnings are emitted.
+- **UNIQUE/CHECK are not enforced**: They are accepted for SQLAlchemy compatibility, ignored by the backend, and compile-time warnings are emitted for `CREATE TABLE` and `ALTER TABLE ... ADD COLUMN`.
 - **Identifier restrictions**: Table and column names must match `[A-Za-z_][A-Za-z0-9_]*`.
 - **No concurrent writes**: Use a single-writer model.
 - **Rollback**: Partial support — works with the openpyxl backend when `autocommit=False` (snapshot/restore semantics). The Graph API backend treats rollback as a no-op.

src/sqlalchemy_excel/__init__.py

@@ -4,9 +4,14 @@
 
 from importlib.metadata import PackageNotFoundError, version
 
+from sqlalchemy.dialects import registry
+
 from .dialect import ExcelDialect, ExcelGraphDialect
 from .dml import Insert, insert
 
+registry.register("excel", "sqlalchemy_excel.dialect", "ExcelDialect")
+registry.register("excel.graph", "sqlalchemy_excel.dialect", "ExcelGraphDialect")
+
 try:
     __version__ = version("sqlalchemy-excel")
 except PackageNotFoundError:

src/sqlalchemy_excel/ddl.py

@@ -18,6 +18,42 @@
 class ExcelDDLCompiler(compiler.DDLCompiler):
     """Compiles DDL statements for excel-dbapi."""
 
+    @staticmethod
+    def _warn_unsupported_constraints(
+        column: Any,
+        context_msg: str,
+        seen_unique: set[tuple[str, ...]],
+        seen_check: set[str],
+    ) -> None:
+        if column.unique is True:
+            key = (column.name,)
+            if key not in seen_unique:
+                warnings.warn(
+                    f"Excel dialect does not enforce UNIQUE constraints ({context_msg})",
+                    stacklevel=2,
+                )
+                seen_unique.add(key)
+
+        for constraint in column.constraints:
+            if isinstance(constraint, UniqueConstraint):
+                unique_key = tuple(col.name for col in constraint.columns) or (
+                    column.name,
+                )
+                if unique_key not in seen_unique:
+                    warnings.warn(
+                        f"Excel dialect does not enforce UNIQUE constraints ({context_msg})",
+                        stacklevel=2,
+                    )
+                    seen_unique.add(unique_key)
+            if isinstance(constraint, CheckConstraint):
+                check_key = str(constraint.sqltext)
+                if check_key not in seen_check:
+                    warnings.warn(
+                        f"Excel dialect does not enforce CHECK constraints ({context_msg})",
+                        stacklevel=2,
+                    )
+                    seen_check.add(check_key)
+
     def _format_alter_table_name(self, operation: Any) -> str:
         schema = getattr(operation, "schema", None)
         if schema is not None:
@@ -48,34 +84,49 @@ def visit_create_table(self, create: Any, **kw: Any) -> str:
 
         columns = []
         pk_columns = {col.name for col in table.primary_key.columns}
+        pk_columns_ordered = [
+            self.preparer.format_column(col) for col in table.primary_key.columns
+        ]
         inline_pk = len(pk_columns) == 1
+        seen_unique: set[tuple[str, ...]] = set()
+        seen_check: set[str] = set()
         for col in table.columns:
             col_name = self.preparer.format_column(col)
             col_type = self.dialect.type_compiler.process(col.type)
             constraints: list[str] = []
-            if col.nullable is False:
+            if col.nullable is False and col.name not in pk_columns:
                 constraints.append("NOT NULL")
             if inline_pk and col.name in pk_columns:
                 constraints.append("PRIMARY KEY")
-            if col.unique is True:
-                warnings.warn(
-                    "Excel dialect does not enforce UNIQUE constraints",
-                    stacklevel=3,
-                )
+            self._warn_unsupported_constraints(
+                col,
+                context_msg="CREATE TABLE",
+                seen_unique=seen_unique,
+                seen_check=seen_check,
+            )
             suffix = f" {' '.join(constraints)}" if constraints else ""
             columns.append(f"{col_name} {col_type}{suffix}")
 
+        if len(pk_columns_ordered) > 1:
+            columns.append(f"PRIMARY KEY ({', '.join(pk_columns_ordered)})")
+
         for constraint in table.constraints:
             if isinstance(constraint, UniqueConstraint):
-                warnings.warn(
-                    "Excel dialect does not enforce UNIQUE constraints",
-                    stacklevel=3,
-                )
+                unique_key = tuple(col.name for col in constraint.columns)
+                if unique_key not in seen_unique:
+                    warnings.warn(
+                        "Excel dialect does not enforce UNIQUE constraints (CREATE TABLE)",
+                        stacklevel=2,
+                    )
+                    seen_unique.add(unique_key)
             if isinstance(constraint, CheckConstraint):
-                warnings.warn(
-                    "Excel dialect does not enforce CHECK constraints",
-                    stacklevel=3,
-                )
+                check_key = str(constraint.sqltext)
+                if check_key not in seen_check:
+                    warnings.warn(
+                        "Excel dialect does not enforce CHECK constraints (CREATE TABLE)",
+                        stacklevel=2,
+                    )
+                    seen_check.add(check_key)
 
         return f"CREATE TABLE {table_name} ({', '.join(columns)})"
 
@@ -94,10 +145,16 @@ def visit_add_column(self, create: Any, **kw: Any) -> str:
         col_name = self.preparer.format_column(column)
         col_type = self.dialect.type_compiler.process(column.type)
         constraints: list[str] = []
-        if column.nullable is False:
+        if column.nullable is False and column.primary_key is not True:
             constraints.append("NOT NULL")
         if column.primary_key is True:
             constraints.append("PRIMARY KEY")
+        self._warn_unsupported_constraints(
+            column,
+            context_msg="ALTER TABLE ADD COLUMN",
+            seen_unique=set(),
+            seen_check=set(),
+        )
         suffix = f" {' '.join(constraints)}" if constraints else ""
         return f"ALTER TABLE {table_name} ADD COLUMN {col_name} {col_type}{suffix}"