fix(oracle): restore catalog-aware constraint reflection

[IceS2]

Backports #31676 to 2.0.

This applies catalog-aware Oracle primary-key, unique-constraint, and foreign-key reflection and preserves backing-index metadata.

Focused verification: 4 Oracle constraint-reflection tests passed.

Greptile Summary

Restores catalog-aware Oracle constraint reflection by overriding primary-key, unique-constraint, and foreign-key inspection while retaining backing-index metadata.

• Uses the configured Oracle catalog prefix for constraint queries.
• Handles synonym and database-link reflection arguments.
• Adds focused tests for DBA/ALL catalogs, empty results, and synonym resolution.

Confidence Score: 5/5

The pull request appears safe to merge, with no concrete changed-code failure established.

The new reflection methods preserve the expected constraint shapes, route queries through the configured Oracle catalog, and include focused coverage for the principal catalog and synonym paths.

Important Files Changed

Filename	Overview
ingestion/src/metadata/ingestion/source/database/oracle/metadata.py	Rebinds the three public Oracle constraint-reflection methods to catalog-aware implementations.
ingestion/src/metadata/ingestion/source/database/oracle/queries.py	Extends the constraint query with the backing index name needed for unique-constraint metadata.
ingestion/src/metadata/ingestion/source/database/oracle/utils.py	Implements catalog-aware PK, unique, and foreign-key reflection with identifier, synonym, and database-link handling.
ingestion/tests/unit/topology/database/test_oracle_constraint_reflection.py	Verifies both catalog prefixes, empty reflection results, backing-index metadata, and synonym resolution.

Sequence Diagram

sequenceDiagram
    participant Ingestion as Oracle ingestion
    participant Inspector as SQLAlchemy Inspector
    participant Dialect as Patched OracleDialect
    participant Catalog as Oracle catalog
    Ingestion->>Inspector: Reflect table constraints
    Inspector->>Dialect: get_pk_constraint / get_unique_constraints / get_foreign_keys
    Dialect->>Dialect: Resolve synonym and normalize identifiers
    Dialect->>Catalog: Query configured DBA_ or ALL_ catalog views
    Catalog-->>Dialect: Constraint rows and backing index names
    Dialect-->>Inspector: SQLAlchemy reflection metadata
    Inspector-->>Ingestion: PK, unique, and foreign-key definitions

Loading

_{Reviews (1): Last reviewed commit: "fix(oracle): restore catalog-aware const..." | Re-trigger Greptile}

[github-actions]

❌ PR checklist incomplete

This PR cannot be merged until the following are addressed on its linked issue:

• No GitHub issue is linked. Link an issue in the Development section of the PR (or add Fixes #12345 to the description). For a same-org cross-repo issue, add Fixes open-metadata/<repo>#123 to the description.

The fields live on the linked issue in the Shipping project (open the issue → right sidebar → Projects). After you set them, re-run this check (or push a commit) — issue/project changes do not re-trigger it automatically.

Maintainers can bypass this check by adding the skip-pr-checks label.

[github-actions]

The Python checkstyle failed.

Please run make py_format and py_format_check in the root of your repository and commit the changes to this PR.
You can also use pre-commit to automate the Python code formatting.

You can install the pre-commit hooks with make install_test precommit_install.

[gitar-bot]

⚠️ Bug: Synonym resolution skips denormalization when no synonym found

In _prepare_constraint_args, when oracle_resolve_synonyms=True but self._get_synonyms(...) returns no rows (the table is a real table, not a synonym), table_name/schema are never denormalized and are passed to the query as the raw (typically lowercase) input. Since Oracle stores identifiers uppercase, ac.table_name = :table_name won't match and PK/UQ/FK reflection silently returns empty. Upstream SQLAlchemy always falls back to denormalize_name(...) in this case. Fix by denormalizing on the no-synonym fallback path.

Always denormalize on the no-synonym fallback, matching upstream behavior.:

def _prepare_constraint_args(self, connection, table_name, schema, **kw):
    dblink = kw.get("dblink", "")
    if dblink and not dblink.startswith("@"):
        dblink = f"@{dblink}"

    if kw.get("oracle_resolve_synonyms", False):
        rows = list(
            self._get_synonyms(
                connection, schema, [table_name], dblink,
                info_cache=kw.get("info_cache"),
            )
        )
        if rows:
            row = rows[0]
            table_name = self.denormalize_name(row.table_name)
            schema = self.denormalize_name(row.table_owner)
            if row.db_link:
                dblink = row.db_link if row.db_link.startswith("@") else f"@{row.db_link}"
            return table_name, schema, dblink

    table_name = self.denormalize_name(table_name)
    schema = self.denormalize_name(schema or self.default_schema_name)
    return table_name, schema, dblink

_{Was this helpful? React with 👍 / 👎}

[gitar-bot]

Code Review ⚠️ Changes requested 0 resolved / 1 findings

Backports catalog-aware Oracle constraint reflection to target branch. However, synonym resolution skips denormalization when no synonym is found, which breaks constraint argument preparation.

⚠️ Bug: Synonym resolution skips denormalization when no synonym found

📄 ingestion/src/metadata/ingestion/source/database/oracle/utils.py:422-436

In _prepare_constraint_args, when oracle_resolve_synonyms=True but self._get_synonyms(...) returns no rows (the table is a real table, not a synonym), table_name/schema are never denormalized and are passed to the query as the raw (typically lowercase) input. Since Oracle stores identifiers uppercase, ac.table_name = :table_name won't match and PK/UQ/FK reflection silently returns empty. Upstream SQLAlchemy always falls back to denormalize_name(...) in this case. Fix by denormalizing on the no-synonym fallback path.

Always denormalize on the no-synonym fallback, matching upstream behavior.

def _prepare_constraint_args(self, connection, table_name, schema, **kw):
    dblink = kw.get("dblink", "")
    if dblink and not dblink.startswith("@"):
        dblink = f"@{dblink}"

    if kw.get("oracle_resolve_synonyms", False):
        rows = list(
            self._get_synonyms(
                connection, schema, [table_name], dblink,
                info_cache=kw.get("info_cache"),
            )
        )
        if rows:
            row = rows[0]
            table_name = self.denormalize_name(row.table_name)
            schema = self.denormalize_name(row.table_owner)
            if row.db_link:
                dblink = row.db_link if row.db_link.startswith("@") else f"@{row.db_link}"
            return table_name, schema, dblink

    table_name = self.denormalize_name(table_name)
    schema = self.denormalize_name(schema or self.default_schema_name)
    return table_name, schema, dblink

🤖 Prompt for agents

Code Review: Backports catalog-aware Oracle constraint reflection to target branch. However, synonym resolution skips denormalization when no synonym is found, which breaks constraint argument preparation.

1. ⚠️ Bug: Synonym resolution skips denormalization when no synonym found
   Files: ingestion/src/metadata/ingestion/source/database/oracle/utils.py:422-436

   In `_prepare_constraint_args`, when `oracle_resolve_synonyms=True` but `self._get_synonyms(...)` returns no rows (the table is a real table, not a synonym), `table_name`/`schema` are never denormalized and are passed to the query as the raw (typically lowercase) input. Since Oracle stores identifiers uppercase, `ac.table_name = :table_name` won't match and PK/UQ/FK reflection silently returns empty. Upstream SQLAlchemy always falls back to `denormalize_name(...)` in this case. Fix by denormalizing on the no-synonym fallback path.

   Fix (Always denormalize on the no-synonym fallback, matching upstream behavior.):
   def _prepare_constraint_args(self, connection, table_name, schema, **kw):
       dblink = kw.get("dblink", "")
       if dblink and not dblink.startswith("@"):
           dblink = f"@{dblink}"
   
       if kw.get("oracle_resolve_synonyms", False):
           rows = list(
               self._get_synonyms(
                   connection, schema, [table_name], dblink,
                   info_cache=kw.get("info_cache"),
               )
           )
           if rows:
               row = rows[0]
               table_name = self.denormalize_name(row.table_name)
               schema = self.denormalize_name(row.table_owner)
               if row.db_link:
                   dblink = row.db_link if row.db_link.startswith("@") else f"@{row.db_link}"
               return table_name, schema, dblink
   
       table_name = self.denormalize_name(table_name)
       schema = self.denormalize_name(schema or self.default_schema_name)
       return table_name, schema, dblink

Options

Display: compact → Showing less information.

Comment with these commands to change the behavior for this request:

Compact

gitar display:verbose

_{Was this helpful? React with 👍 / 👎 | Powered by Gitar — free for open source}