feat(oracle): adapt to derived DDL with typed options and partition lifecycle

.github/workflows/test.yml

@@ -53,7 +53,7 @@
       - name: Install activerecord and testsuite from git
         run: |
           pip install "rhosocial-activerecord @ git+https://github.com/rhosocial/python-activerecord.git@release/v1.0.0.dev30"
-          pip install "rhosocial-activerecord-testsuite @ git+https://github.com/rhosocial/python-activerecord-testsuite.git@feature/activerecord-derived-ddl"
+          pip install "rhosocial-activerecord-testsuite @ git+https://github.com/rhosocial/python-activerecord-testsuite.git@release/v1.0.0.dev17"
 
       - name: Wait for Oracle and test connectivity
         run: |
@@ -181,7 +181,7 @@
       - name: Install activerecord and testsuite from git
         run: |
           pip install "rhosocial-activerecord @ git+https://github.com/rhosocial/python-activerecord.git@release/v1.0.0.dev30"
-          pip install "rhosocial-activerecord-testsuite @ git+https://github.com/rhosocial/python-activerecord-testsuite.git@feature/activerecord-derived-ddl"
+          pip install "rhosocial-activerecord-testsuite @ git+https://github.com/rhosocial/python-activerecord-testsuite.git@release/v1.0.0.dev17"
 
       - name: Wait for Oracle and test connectivity
         run: |
@@ -309,7 +309,7 @@
       - name: Install activerecord and testsuite from git
         run: |
           pip install "rhosocial-activerecord @ git+https://github.com/rhosocial/python-activerecord.git@release/v1.0.0.dev30"
-          pip install "rhosocial-activerecord-testsuite @ git+https://github.com/rhosocial/python-activerecord-testsuite.git@feature/activerecord-derived-ddl"
+          pip install "rhosocial-activerecord-testsuite @ git+https://github.com/rhosocial/python-activerecord-testsuite.git@release/v1.0.0.dev17"
 
       - name: Wait for Oracle and test connectivity
         run: |

CLAUDE.md

@@ -35,3 +35,9 @@ This project is in early development. Key features being implemented:
 ## Version Control and Changelog
 
 This project adheres to the same version control, branching, commit message, and changelog management standards as the main `python-activerecord` project.
+
+## Search Scope
+
+- Use `rg` for repository searches; never use `grep`.
+- Limit searches to this `python-activerecord` repository and its related testsuite/backend directories.
+- Exclude `.git/`, `.venv*/`, `__pycache__/`, `build/`, `dist/`, and other cache directories.

changelog.d/20.added.md

@@ -0,0 +1 @@
+Add Oracle materialized view refresh via `OracleRefreshMaterializedViewExpression`, which renders a `DBMS_MVIEW.REFRESH` PL/SQL block. Oracle has no standalone `REFRESH MATERIALIZED VIEW` statement, so refresh was previously unreachable. Supports the procedure's refresh method codes (`F`/`C`/`?`/`P`/`A`, which differ from the `REFRESH FAST`/`COMPLETE` DDL keywords) plus `atomic_refresh`, `out_of_place`, `nested`, `parallelism`, `purge_option`, `refresh_after_errors` and `push_deferred_rpc`. `supports_refresh_materialized_view()` now reports `True` and the generic `RefreshMaterializedViewExpression` routes to the same formatter.

changelog.d/5.added.md

@@ -0,0 +1 @@
+Adapt the Oracle backend to derived DDL: `OracleColumnDefinition` with typed column options, a partition lifecycle provider with the provider protocol declared, partition definitions derived from the generic base declarations, type DDL support, `DROP TABLE ... PURGE` rendering, `CommentSupport` classification, index drop by bare name without `ON <table>`, `OracleDatabaseMixin` wiring, and materialized view refresh via `DBMS_MVIEW.REFRESH`.

changelog.d/5.fixed.md

@@ -0,0 +1 @@
+Stop the Oracle backend from discarding or over-claiming declared DDL: `supports_temporal_tables` is declared `False` instead of left unstated, unrenderable `ALTER SCHEMA` capabilities are no longer advertised, `supports_comment` is renamed to `supports_comment_on` and declared comments are no longer dropped, `CREATE VIEW ... WITH CHECK OPTION` is gated on `supports_view_check_option`, `DROP TYPE` no longer applies a default `VALIDATE`, and `DROP TABLE ... PURGE` renders independently of `CASCADE`.

changelog.d/5.internal.md

@@ -0,0 +1 @@
+Install core and testsuite from release branches in CI instead of the derived-DDL feature branch, repair TYPE_CHECKING imports broken by the expression namespace split, register the pytest markers the suite already uses, and stop the pre-commit hook from blocking commits on revisions that predate `scripts/preflight.sh`.

changelog.d/5.removed.md

@@ -0,0 +1 @@
+Remove the reserved `dialect_options` bag from data-type value objects, DDL expressions, the insert/merge formatters and `OracleForUpdateClause`, replace the legacy partition bag paths with typed dispatch, drop the legacy identity fields from column classes, and remove the generated DDL lifecycle.

pyproject.toml

@@ -90,6 +90,9 @@ markers = [
     "requires_protocol: marks tests requiring specific backend protocol support",
     "requires_inner_join: marks tests requiring INNER JOIN support",
     "backend: marks tests for backend-specific features",
+    "feature: category label for feature-area tests; changes collection grouping only, not ordering",
+    "benchmark_relation: marks relation benchmarks; changes collection grouping only, not ordering",
+
 ]
 
 [tool.coverage.run]

scripts/install-git-hooks.sh

@@ -4,21 +4,42 @@
 # Installs an optional pre-commit hook that runs scripts/preflight.sh so a
 # broken import/lint is caught before the commit (and before a CI round-trip).
 # Bypass a single commit with: git commit --no-verify
+#
+# Re-run this after pulling, and re-run it from the repository root. To remove
+# the hook, delete .git/hooks/pre-commit (or the core.hooksPath directory).
 set -euo pipefail
 
 cd "$(dirname "$0")/.."
 
-HOOK=".git/hooks/pre-commit"
-if [ ! -d .git/hooks ]; then
-  echo "install-git-hooks: .git/hooks not found (not a git repo?)" >&2
-  exit 2
+# git ignores .git/hooks entirely once core.hooksPath is set, so a hook written
+# there would never run while this script still reported success.
+HOOKS_PATH="$(git config core.hooksPath || true)"
+if [ -n "$HOOKS_PATH" ]; then
+  echo "install-git-hooks: core.hooksPath is set to '$HOOKS_PATH'." >&2
+  echo "install-git-hooks: .git/hooks is ignored by git; writing the hook to" >&2
+  echo "                 '$HOOKS_PATH/pre-commit' instead." >&2
+  HOOK="$HOOKS_PATH/pre-commit"
+  mkdir -p "$HOOKS_PATH"
+else
+  HOOK=".git/hooks/pre-commit"
+  if [ ! -d .git/hooks ]; then
+    echo "install-git-hooks: .git/hooks not found (not a git repo?)" >&2
+    exit 2
+  fi
 fi
 
 cat > "$HOOK" <<'HOOK_BODY'
 #!/usr/bin/env bash
 # Installed by scripts/install-git-hooks.sh — runs the local pre-flight.
 # Skip with: git commit --no-verify
-exec "$(git rev-parse --show-toplevel)/scripts/preflight.sh"
+#
+# The guard below matters on older revisions: this hook is a local, untracked
+# artifact, so it survives a checkout of a commit that predates
+# scripts/preflight.sh. Without the guard, exec fails with a bare
+# "No such file or directory" and blocks the commit with nothing to act on.
+PREFLIGHT="$(git rev-parse --show-toplevel)/scripts/preflight.sh"
+[ -x "$PREFLIGHT" ] || exit 0
+exec "$PREFLIGHT"
 HOOK_BODY
 chmod +x "$HOOK"
 

src/rhosocial/activerecord/backend/impl/oracle/__init__.py

@@ -75,6 +75,40 @@
     OracleVarChar2Type,
     OracleXmlType,
 )
+from .expression.ddl.type import (
+    DropTypeBodyExpression,
+    OracleAlterTypeAddAttributeAction,
+    OracleAlterTypeAddMethodAction,
+    OracleAlterTypeCompileAction,
+    OracleAlterTypeDependentHandling,
+    OracleTypeDependentHandling,
+    OracleAlterTypeAttributeAction,
+    OracleAlterTypeMethodAction,
+    OracleAlterTypeModifyLimitAction,
+    OracleCompileTypeAction,
+    OracleSetTypeFinalAction,
+    OracleSetTypeInstantiableAction,
+    OracleAlterTypeDropAttributeAction,
+    OracleAlterTypeDropMethodAction,
+    OracleAlterTypeElementTypeAction,
+    OracleAlterTypeFinalAction,
+    OracleAlterTypeInstantiableAction,
+    OracleAlterTypeLimitAction,
+    OracleAlterTypeModifyAttributeAction,
+    OracleAlterTypeResetAction,
+    OracleCreateTypeBodyExpression,
+    OracleDropTypeBodyExpression,
+    OracleDropTypeExpression,
+    OracleIncompleteTypeDefinition,
+    OracleNestedTableTypeDefinition,
+    OracleObjectTypeDefinition,
+    OracleSqljTypeDefinition,
+    OracleTypeAlterAction,
+    OracleTypeAttribute,
+    OracleTypeMethod,
+    OracleVarrayTypeDefinition,
+)
+from .version import VERSION_FULL_QUERY, VERSION_QUERY, ru_from_version_full
 
 from .schema import OracleSchemaDiffer
 
@@ -143,6 +177,42 @@
     "OracleLongRawType",
     "OracleBlobType",
 
+    # User-defined TYPE DDL
+    "OracleTypeAttribute",
+    "OracleTypeMethod",
+    "OracleObjectTypeDefinition",
+    "OracleSqljTypeDefinition",
+    "OracleVarrayTypeDefinition",
+    "OracleNestedTableTypeDefinition",
+    "OracleIncompleteTypeDefinition",
+    "OracleAlterTypeDependentHandling",
+    "OracleTypeDependentHandling",
+    "OracleAlterTypeAttributeAction",
+    "OracleAlterTypeMethodAction",
+    "OracleAlterTypeModifyLimitAction",
+    "OracleCompileTypeAction",
+    "OracleSetTypeFinalAction",
+    "OracleSetTypeInstantiableAction",
+    "OracleTypeAlterAction",
+    "OracleAlterTypeAddAttributeAction",
+    "OracleAlterTypeModifyAttributeAction",
+    "OracleAlterTypeDropAttributeAction",
+    "OracleAlterTypeAddMethodAction",
+    "OracleAlterTypeDropMethodAction",
+    "OracleAlterTypeLimitAction",
+    "OracleAlterTypeElementTypeAction",
+    "OracleAlterTypeCompileAction",
+    "OracleAlterTypeFinalAction",
+    "OracleAlterTypeInstantiableAction",
+    "OracleAlterTypeResetAction",
+    "OracleCreateTypeBodyExpression",
+    "OracleDropTypeExpression",
+    "DropTypeBodyExpression",
+    "OracleDropTypeBodyExpression",
+    "VERSION_FULL_QUERY",
+    "VERSION_QUERY",
+    "ru_from_version_full",
+
     # Schema differ
     "OracleSchemaDiffer",
 

src/rhosocial/activerecord/backend/impl/oracle/async_backend.py

@@ -33,6 +33,13 @@
 from .dialect import OracleDialect
 from .async_transaction import AsyncOracleTransactionManager
 from .mixins import OracleBackendMixin
+from .version import (
+    VERSION_FULL_QUERY,
+    VERSION_QUERY,
+    normalize_version,
+    parse_version_row,
+    ru_from_version_full,
+)
 from .backend import OracleBackend, _is_numeric_python_type
 
 
@@ -42,6 +49,8 @@ class AsyncOracleBackend(OracleBackendMixin, IntrospectorBackendMixin, AsyncStor
     def __init__(self, **kwargs):
         """Initialize async Oracle backend."""
         version = kwargs.pop('version', None) or (19, 0, 0)
+        version_full = kwargs.pop('version_full', None)
+        ru_version = kwargs.pop('ru_version', None)
 
         connection_config = kwargs.get('connection_config')
 
@@ -72,6 +81,10 @@ def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
         self._version = version or (19, 0, 0)
+        self._version_full = normalize_version(version_full, minimum_length=2) or None
+        self._ru_version = (
+            ru_version if ru_version is not None else ru_from_version_full(self._version_full)
+        )
         self._current_column_types = None
         self._dialect = None
         self._transaction_manager = AsyncOracleTransactionManager(None, self.logger)
@@ -94,7 +107,11 @@ def transaction_manager(self) -> AsyncOracleTransactionManager:
     def dialect(self) -> OracleDialect:
         """Get Oracle SQL dialect."""
         if self._dialect is None:
-            self._dialect = OracleDialect(self._version)
+            self._dialect = OracleDialect(
+                self._version,
+                version_full=self._version_full,
+                ru_version=self._ru_version,
+            )
         return self._dialect
 
     async def _handle_auto_commit(self) -> None:
@@ -112,10 +129,37 @@ async def introspect_and_adapt(self) -> None:
         """Introspect backend and adapt to actual server capabilities."""
         if not self._connection:
             await self.connect()
+        previous_version = getattr(self, "_version", None)
+        previous_version_full = getattr(self, "_version_full", None)
+        previous_ru_version = getattr(self, "_ru_version", None)
+        previous_dialect = getattr(self, "_dialect", None)
         actual_version = await self.get_server_version()
-        if self._version != actual_version:
+        actual_version_full = getattr(self, "_version_full", None)
+        if actual_version_full is None:
+            actual_version_full = await self.get_server_version_full()
+        actual_ru_version = getattr(self, "_ru_version", None)
+        if actual_ru_version is None and actual_version_full is not None:
+            actual_ru_version = ru_from_version_full(actual_version_full)
+        dialect_version = getattr(previous_dialect, "_version", None)
+        dialect_version_full = getattr(previous_dialect, "version_full", None)
+        dialect_ru_version = getattr(previous_dialect, "ru_version", None)
+        if (
+            previous_version != actual_version
+            or previous_version_full != actual_version_full
+            or previous_ru_version != actual_ru_version
+            or previous_dialect is None
+            or dialect_version != actual_version
+            or dialect_version_full != actual_version_full
+            or dialect_ru_version != actual_ru_version
+        ):
             self._version = actual_version
-            self._dialect = OracleDialect(actual_version)
+            self._version_full = actual_version_full
+            self._ru_version = actual_ru_version
+            self._dialect = OracleDialect(
+                actual_version,
+                version_full=actual_version_full,
+                ru_version=actual_ru_version,
+            )
             self._register_oracle_adapters()
             self.log(logging.INFO, f"Adapted to Oracle server version {actual_version}")
 
@@ -562,29 +606,44 @@ async def execute_many(self, sql: str, params_list: List[Tuple]) -> QueryResult:
                 cursor.close()
 
     async def get_server_version(self) -> tuple:
-        """Get Oracle server version asynchronously."""
+        """Get the Oracle base and full release versions asynchronously."""
         if not self._connection:
             await self.connect()
 
         cursor = None
         try:
             cursor = await self._get_cursor()
-            await cursor.execute("SELECT VERSION FROM PRODUCT_COMPONENT_VERSION WHERE PRODUCT LIKE 'Oracle%'")
-            row = await cursor.fetchone()
-            version_str = row[0]
-
-            version_parts = version_str.split('.')
-            major = int(version_parts[0]) if len(version_parts) > 0 else 0
-            minor = int(version_parts[1]) if len(version_parts) > 1 else 0
-            patch = int(version_parts[2]) if len(version_parts) > 2 else 0
-
-            return (major, minor, patch)
+            try:
+                await cursor.execute(VERSION_FULL_QUERY)
+                row = await cursor.fetchone()
+                base, version_full = parse_version_row(row)
+            except Exception:
+                cursor.close()
+                cursor = await self._get_cursor()
+                await cursor.execute(VERSION_QUERY)
+                row = await cursor.fetchone()
+                base, version_full = parse_version_row(row)
+            base = normalize_version(base)[:3]
+            if not base:
+                raise ValueError("Oracle PRODUCT_COMPONENT_VERSION returned no version")
+            self._version_full = version_full
+            self._ru_version = ru_from_version_full(version_full)
+            return base
         except Exception:
+            self._version_full = None
+            self._ru_version = None
             return (19, 0, 0)
         finally:
             if cursor:
                 cursor.close()
 
+    async def get_server_version_full(self) -> Optional[Tuple[int, ...]]:
+        """Return the full Oracle version, including the RU when available."""
+        if self._version_full is not None:
+            return self._version_full
+        await self.get_server_version()
+        return self._version_full
+
     async def ping(self, reconnect: bool = True) -> bool:
         """Ping the Oracle server asynchronously."""
         try: