plsqlwks 0.2.1__tar.gz → 0.2.2__tar.gz

{plsqlwks-0.2.1 → plsqlwks-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plsqlwks
-Version: 0.2.1
+Version: 0.2.2
 Summary: An ncurses SQL and PL/SQL workspace for Oracle databases.
 Author: unu2000
 License-Expression: LicenseRef-plsqlwks-Donationware
@@ -749,12 +749,16 @@ also works from Command Prompt and continues to support PuTTY.
 | `Ctrl+=` | Reconnect |
 
 Use `/` on a line by itself after PL/SQL objects or anonymous blocks when running a script.
+With no selection, `F11` asks: **To run the whole buffer, press Enter. Esc cancels.**
+Press Enter to continue or Esc/Ctrl+C to cancel before bind prompts and execution.
+Executing selected text does not require this additional confirmation.
 Script execution reports statement progress as `n/total` and stops at the first
 failed statement while preserving earlier results. Scripts are sent directly to
 Oracle, not through SQL*Plus or SQLcl: client commands such as `PROMPT`, `SPOOL`,
 and `SET SERVEROUTPUT`, and `&`/`&&` substitution variables, are rejected before
 bind prompts or execution. Oracle SQL statements such as `SET TRANSACTION`
-remain supported.
+remain supported. A standalone `SET DEFINE OFF` line is accepted locally and
+omitted from database execution. It does not enable substitution variables.
 Execution and explain errors report mapped editor line and column diagnostics.
 The cursor moves only when the buffer still matches the source that was sent to
 Oracle; if it changed while the operation ran, the result warns about the stale

{plsqlwks-0.2.1 → plsqlwks-0.2.2}/README.md

@@ -715,12 +715,16 @@ also works from Command Prompt and continues to support PuTTY.
 | `Ctrl+=` | Reconnect |
 
 Use `/` on a line by itself after PL/SQL objects or anonymous blocks when running a script.
+With no selection, `F11` asks: **To run the whole buffer, press Enter. Esc cancels.**
+Press Enter to continue or Esc/Ctrl+C to cancel before bind prompts and execution.
+Executing selected text does not require this additional confirmation.
 Script execution reports statement progress as `n/total` and stops at the first
 failed statement while preserving earlier results. Scripts are sent directly to
 Oracle, not through SQL*Plus or SQLcl: client commands such as `PROMPT`, `SPOOL`,
 and `SET SERVEROUTPUT`, and `&`/`&&` substitution variables, are rejected before
 bind prompts or execution. Oracle SQL statements such as `SET TRANSACTION`
-remain supported.
+remain supported. A standalone `SET DEFINE OFF` line is accepted locally and
+omitted from database execution. It does not enable substitution variables.
 Execution and explain errors report mapped editor line and column diagnostics.
 The cursor moves only when the buffer still matches the source that was sent to
 Oracle; if it changed while the operation ran, the result warns about the stale

{plsqlwks-0.2.1 → plsqlwks-0.2.2}/doc/API.md

@@ -547,7 +547,11 @@ Required source-schema tables and views are followed recursively; tables include
 their constraints, indexes, triggers, and detected sequences. Selection of callers stays
 limited to direct references to the initially checked tables. Definitions are
 ordered by creation dependencies across object types; unresolved prerequisites
-and genuine dependency cycles are reported in the generated script.
+and genuine dependency cycles are reported in the generated script. Discovery
+prefers ALL_* catalogs and supplements them with accessible DBA_* views.
+Cross-schema definitions use catalog rendering for supported objects and
+DBMS_METADATA fallback for advanced or incomplete metadata. Own-schema
+definitions retain DBMS_METADATA extraction.
 
 On success the host opens and activates a new unsaved tab containing the generated
 SQL, with keyboard focus in the editor. Cancellation,

{plsqlwks-0.2.1 → plsqlwks-0.2.2}/doc/ARCHITECTURE.md

@@ -47,6 +47,32 @@ UI command as force-disconnected, quarantines that worker, and closes the exact
 captured client connection on a best-effort control thread. No server-side kill
 or process termination is attempted, and other tab workers are unaffected.
 
+## Editor rendering
+
+The SQL document remains in memory, with a lazy `ViewportSyntax` cache owned by
+each `Buffer`. The cache keeps line-boundary lexer states and code-bracket
+positions for scanned lines, but retains tokens only for the visible rows and
+one screen above and below. Buffer edits, completion, and undo/redo report their
+changed line ranges. Parsing resumes from the first invalid line and reuses the
+unchanged suffix once its incoming lexer state agrees again. Display and cursor
+movement do not join or tokenize the entire document.
+
+Cold jumps and edits that change multiline strings or comments may need context
+from earlier lines. Parsing and distant bracket searches run in cooperative
+8 ms batches on the curses thread. Unresolved rows appear immediately in the
+default text style; accurate highlighting follows as context becomes available.
+The event loop polls input and database completions between batches, without
+the normal 200 ms idle delay. The budget is checked between lines and bracket
+positions; an exceptionally long individual line can exceed it.
+
+`Renderer` retains a curses window sized to the editor viewport. Small vertical
+scrolls move its existing rows, and row signatures limit painting to exposed or
+changed text, selection, and bracket overlays. Geometry or active-buffer changes
+invalidate the appropriate rows. The root screen and editor window compose via
+`noutrefresh()` and one `doupdate()`, restoring the active cursor after composition.
+Recomposing the retained editor also restores it after overlapping dialogs and
+external terminal use. No document-sized curses pad or rendering thread is used.
+
 ## Transaction state
 
 Each worker-owned `OracleWorkspace` is the detailed source of truth. It tracks
@@ -116,8 +142,10 @@ The Table DDL Export command delegates through `start_table_ddl_export()`.
 Its host controller owns the table checklist with incremental substring filtering
 and cancellable worker jobs. Its database service discovers related sequences
 and directly referencing source-schema program units using bound dictionary
-reads, orders included routines by dependency, and extracts definitions using
-per-handle DBMS_METADATA transforms. Generation creates a fresh unsaved tab only for the originating
+reads, orders included routines by dependency, and supplements ALL_* discovery
+with accessible DBA_* views. Cross-schema definitions use conservative catalog
+renderers; own-schema and unsupported definitions use per-handle DBMS_METADATA
+transforms. Generation creates a fresh unsaved tab only for the originating
 editor/session. Identifier-aware remapping preserves literals and comments and
 reports ambiguous references. The plugin itself never receives database or UI
 internals and generated SQL is never automatically executed.

{plsqlwks-0.2.1 → plsqlwks-0.2.2}/doc/PLUGIN_CATALOG.md

@@ -70,12 +70,21 @@ Type in the table list to filter names immediately by a case-insensitive literal
 substring. **Backspace** edits the filter, **Ctrl+L** clears it, and **/** opens
 an optional filter prompt for text containing spaces. An empty filter shows all
 tables. Use arrows/Page Up/Page Down/Home/End to navigate, **Space** to toggle
-an entry, **Ctrl+A** to select matching tables, and **Ctrl+U** to deselect them.
+an entry, **F2** to select matching tables, and **Ctrl+U** to deselect them.
 Checked tables stay selected when hidden by a filter; the screen shows both
 total and visible selection counts. **Enter** exports the checked tables,
 including hidden selections. **Esc** or **Ctrl+C** cancels, including during
 metadata reads. At least one table must be checked.
 
+During metadata reads and DDL generation, the screen shows **Elapsed: HH:MM:SS**.
+The timer resets for each operation and excludes time spent selecting tables
+or answering prompts. There is no percentage estimate.
+
+Generated scripts begin with `SET DEFINE OFF` so SQL*Plus does not prompt for
+ampersands in definitions, such as an `&afcid` string literal. PLSQLWKS accepts
+this standalone directive locally without sending it to Oracle. Generation
+opens the script in a new unsaved editor tab; it does not execute it.
+
 There is no sequence-selection dialog. Source-schema sequences referenced by
 defaults and Oracle-recorded table/trigger/program-unit dependencies are included
 automatically. Trigger bodies are also scanned for explicit NEXTVAL/CURRVAL
@@ -89,7 +98,11 @@ For ordinary sequences, START WITH uses the exporting session's CURRVAL plus
 INCREMENT BY when CURRVAL is defined, taking priority over the metadata cache
 boundary. A cycling sequence wraps at its configured bounds; an exhausted
 noncycling sequence stops the export with an error. If CURRVAL is undefined in
-that session (ORA-08002), the original DBMS_METADATA START WITH is preserved.
+that session (ORA-08002), the metadata START WITH is preserved. Cross-schema
+catalog rendering obtains that snapshot from ALL_SEQUENCES.LAST_NUMBER or,
+when available, DBA_SEQUENCES.LAST_NUMBER. If the account cannot read CURRVAL,
+the snapshot is retained after confirming the sequence remains catalog-visible.
+Dictionary access alone does not grant access to sequence values.
 Scalable/sharded sequences retain their metadata restart position with a review
 comment because raw CURRVAL includes offsets. Other sequence options remain intact.
 
@@ -147,11 +160,44 @@ SQL, ambiguous qualifiers, and source qualifiers in strings receive review
 notes. Dependencies outside the export appear as prerequisites in the script
 header; Oracle metadata cannot discover every dynamic or indirect dependency.
 
-The source account must be able to retrieve each requested object's metadata.
-Normally this means owning the objects; cross-schema extraction requires
-appropriate DBMS_METADATA catalog privileges, such as SELECT_CATALOG_ROLE.
-Having SELECT on another schema's table alone is insufficient. Metadata errors
-abort generation instead of presenting an incomplete export as successful.
+The host prefers ALL_* catalog views and supplements discovery with readable
+DBA_* views, even when ALL_* returns only part of the schema. For example, a
+sequence absent from ALL_SEQUENCES can be exported using DBA_SEQUENCES. Access
+is checked per view using actual queries; the exporter neither enables roles
+nor requests grants. Catalog visibility limits which dependencies can be found.
+
+For objects owned by the session user, definitions still come from per-handle
+DBMS_METADATA calls. Cross-schema exports first render ordinary permanent heap
+tables, scalar columns/defaults, constraints, B-tree/function-based indexes,
+global sequences, ordinary views, and readable PL/SQL source from catalog
+metadata. Stored source and view text are read in full. Changing CURRENT_SCHEMA
+does not change ownership or metadata privileges.
+
+Catalog rendering supports identity, virtual, invisible, and collated table
+columns. Identity generation modes and sequence options are preserved; restart
+uses this session's readable CURRVAL plus the increment, or the backing
+sequence's catalog LAST_NUMBER snapshot if CURRVAL is undefined or inaccessible.
+Export never calls NEXTVAL and does not recreate the internal identity sequence
+separately. These snapshots may leave cache gaps and do not track concurrent
+sessions. If neither restart source is usable, export requires metadata instead
+of resetting numbering to the identity's initial value.
+
+Virtual expressions are read in full. Visible columns retain their current
+SELECT * order, including columns made visible again; invisible columns follow
+in internal-column order. System-generated hidden columns are recreated by their
+constraints/indexes. Named table and column collations are preserved, including
+the original columns behind internal collation keys. Named collations require
+the destination database to support data-bound collation (MAX_STRING_SIZE=EXTENDED).
+
+Advanced features use DBMS_METADATA instead, including partitioned/IOT/external/
+object tables, encrypted columns, edition-specific virtual-column clauses, specialized indexes
+(including descending indexes), constrained or specialized views, and session/
+scalable/sharded sequences. This fallback requires the object owner or appropriate
+DBMS_METADATA catalog privileges, such as SELECT_CATALOG_ROLE. Object grants or
+readable DBA_* views do not by themselves guarantee DBMS_METADATA access.
+If both paths fail for an included object, generation stops with its name and
+the reasons, including the column and unsupported feature or missing column
+metadata where applicable; no incomplete export buffer is opened.
 
 Review and save the script normally. Export does not execute SQL, create the
 destination schema, copy rows, grant privileges, commit, roll back, or drain

{plsqlwks-0.2.1 → plsqlwks-0.2.2}/doc/QUICKSTART.md

@@ -157,8 +157,9 @@ select count(*) as visible_objects
 from user_objects;
 ```
 
-`F11` runs the whole buffer (or the selection). Press `F6` to switch between
-normal results and captured `DBMS_OUTPUT`.
+`F11` runs the whole buffer (or the selection). When running the whole buffer,
+press Enter at the confirmation prompt to continue, or Esc/Ctrl+C to cancel.
+Press `F6` to switch between normal results and captured `DBMS_OUTPUT`.
 
 ### Page through a larger result
 

{plsqlwks-0.2.1 → plsqlwks-0.2.2}/plsqlwks/__init__.py

@@ -1,3 +1,3 @@
 """ncurses SQL and PL/SQL workspace."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{plsqlwks-0.2.1 → plsqlwks-0.2.2}/plsqlwks/db/table_export.py

@@ -12,6 +12,7 @@ import oracledb
 
 from .ddl_remap import ddl_tokens, function_references, remap_sql, sequence_references
 from .identifiers import normalize_identifier, quote_identifier
+from .table_export_catalog import CatalogUnavailable, ExportCatalog, error_code, sequence_restart_value
 
 _METADATA_TYPES = {'PACKAGE': 'PACKAGE_SPEC', 'PACKAGE BODY': 'PACKAGE_BODY'}
 _SEQUENCE_START = re.compile(r'START\s+WITH\s+([+-]?\d+)', re.IGNORECASE)
@@ -125,6 +126,8 @@ class TableExportService:
     def __init__(self, connection: oracledb.Connection, cancelled: Callable[[], bool] = lambda: False):
         self.connection = connection
         self.cancelled = cancelled
+        self.catalog = ExportCatalog(lambda sql, **binds: self.rows(sql, **binds))
+        self._session_user: str | None = None
 
     def check_cancelled(self) -> None:
         if self.cancelled():
@@ -139,27 +142,35 @@ class TableExportService:
     def current_schema(self) -> str:
         return str(self.rows("select sys_context('USERENV', 'CURRENT_SCHEMA') from dual")[0][0])
 
+    def session_user(self) -> str:
+        if self._session_user is None:
+            self._session_user = str(self.rows("select sys_context('USERENV', 'SESSION_USER') from dual")[0][0])
+        return self._session_user
+
     def tables(self, schema: str) -> tuple[str, ...]:
-        return tuple(row[0] for row in self.rows(
+        materialized = {row[0] for row in self.catalog.rows(
+            'select mview_name from all_mviews where owner = :owner', owner=schema,
+        )}
+        return tuple(sorted(row[0] for row in self.catalog.rows(
             """select table_name from all_tables t where owner = :owner
                and nested = 'NO' and secondary = 'N'
                and (iot_type is null or iot_type = 'IOT')
                and table_name not like 'BIN$%'
-               and not exists (select 1 from all_mviews m where m.owner = t.owner and m.mview_name = t.table_name)
                order by table_name""", owner=schema,
-        ))
+        ) if row[0] not in materialized))
 
     def sequences(self, schema: str) -> tuple[str, ...]:
-        return tuple(row[0] for row in self.rows(
+        identities = {row[0] for row in self.catalog.rows(
+            'select sequence_name from all_tab_identity_cols where owner = :owner', owner=schema,
+        )}
+        return tuple(sorted(row[0] for row in self.catalog.rows(
             """select s.sequence_name from all_sequences s where s.sequence_owner = :owner
-               and not exists (select 1 from all_tab_identity_cols i
-                 where i.owner = s.sequence_owner and i.sequence_name = s.sequence_name)
                order by s.sequence_name""", owner=schema,
-        ))
+        ) if row[0] not in identities))
 
     def table_dependencies(self, obj: ExportObject, known_objects: set[ExportObject]) -> set[ExportObject]:
         dependencies = self.object_dependencies(obj)
-        for (default,) in self.rows(
+        for (default,) in self.catalog.rows(
             "select data_default from all_tab_cols where owner = :owner and table_name = :name and default_length > 0",
             owner=obj.owner, name=obj.name,
         ):
@@ -173,7 +184,7 @@ class TableExportService:
         dependencies = self.object_dependencies(obj)
         # Both FOLLOWS and PRECEDES require the named trigger to exist first;
         # this is creation order, not the firing order of the resulting triggers.
-        dependencies.update(ExportObject(owner, name, 'TRIGGER') for owner, name in self.rows(
+        dependencies.update(ExportObject(owner, name, 'TRIGGER') for owner, name in self.catalog.rows(
             '''select referenced_trigger_owner, referenced_trigger_name from all_trigger_ordering
                where trigger_owner = :owner and trigger_name = :name''', owner=obj.owner, name=obj.name,
         ))
@@ -183,7 +194,7 @@ class TableExportService:
         for sequence in sorted(candidates - dependencies):
             # A token may name a synonym or a PL/SQL record rather than a
             # sequence. Keep dictionary-resolved synonym dependencies intact.
-            if self.rows(
+            if self.catalog.rows(
                 'select sequence_name from all_sequences where sequence_owner = :owner and sequence_name = :name',
                 owner=sequence.owner, name=sequence.name,
             ):
@@ -204,7 +215,7 @@ class TableExportService:
             visible = known_objects
             if candidate.owner != schema:
                 visible = {ExportObject(candidate.owner, candidate.name, _METADATA_TYPES.get(kind, kind))
-                           for (kind,) in self.rows(
+                           for (kind,) in self.catalog.rows(
                                'select object_type from all_objects where owner = :owner and object_name = :name',
                                owner=candidate.owner, name=candidate.name,
                            )}
@@ -218,7 +229,7 @@ class TableExportService:
         return dependencies
 
     def table_users(self, schema: str, table: str) -> set[ExportObject]:
-        return {ExportObject(schema, name, _METADATA_TYPES.get(kind, kind)) for name, kind in self.rows(
+        return {ExportObject(schema, name, _METADATA_TYPES.get(kind, kind)) for name, kind in self.catalog.rows(
             """select distinct name, type from all_dependencies
                where owner = :owner and referenced_owner = :owner and referenced_name = :name
                  and referenced_type = 'TABLE' and referenced_link_name is null
@@ -228,7 +239,7 @@ class TableExportService:
 
     def object_dependencies(self, obj: ExportObject) -> set[ExportObject]:
         dictionary_kind = {'PACKAGE_SPEC': 'PACKAGE', 'PACKAGE_BODY': 'PACKAGE BODY'}.get(obj.kind, obj.kind)
-        references = {ExportObject(owner, name, _METADATA_TYPES.get(kind, kind)) for owner, name, kind in self.rows(
+        references = {ExportObject(owner, name, _METADATA_TYPES.get(kind, kind)) for owner, name, kind in self.catalog.rows(
             """select distinct referenced_owner, referenced_name, referenced_type from all_dependencies
                where owner = :owner and name = :name and type = :kind
                  and referenced_owner is not null and referenced_link_name is null""",
@@ -239,6 +250,19 @@ class TableExportService:
         return references
 
     def ddl(self, obj: ExportObject, source: str, target: str) -> str:
+        self.check_cancelled()
+        if obj.owner == self.session_user():
+            return self.metadata_ddl(obj, source, target)
+        try:
+            return self.catalog.ddl(obj.owner, obj.name, obj.kind)
+        except CatalogUnavailable as catalog_error:
+            self.check_cancelled()
+            try:
+                return self.metadata_ddl(obj, source, target)
+            except RuntimeError as metadata_error:
+                raise RuntimeError(f'{obj.label}: {catalog_error}; DBMS_METADATA: {metadata_error}') from metadata_error
+
+    def metadata_ddl(self, obj: ExportObject, source: str, target: str) -> str:
         self.check_cancelled()
         with self.connection.cursor() as cursor:
             result = cursor.var(oracledb.DB_TYPE_CLOB)
@@ -298,13 +322,21 @@ class TableExportService:
         try:
             current = int(self.rows(f"select to_char({qualified}.currval, 'TM9') from dual")[0][0])
         except oracledb.DatabaseError as exc:
-            if getattr(exc.args[0], 'code', None) != 8002:
+            code = error_code(exc)
+            if code not in {8002, 1031, 2289}:
                 raise RuntimeError(f'{obj.label}: cannot read CURRVAL: {exc}') from exc
-            return f'-- START WITH {saved} from metadata; CURRVAL is undefined in this session.\n{ddl}'
-        rows = self.rows(
-            '''select increment_by, min_value, max_value, cycle_flag, scale_flag, sharded_flag
+            if code != 8002 and not self.catalog.rows(
+                'select sequence_name from all_sequences where sequence_owner = :owner and sequence_name = :name',
+                owner=obj.owner, name=obj.name,
+            ):
+                raise RuntimeError(f'{obj.label}: sequence disappeared or metadata is no longer accessible') from exc
+            reason = 'undefined in this session' if code == 8002 else 'not accessible to this account'
+            return f'-- START WITH {saved} from metadata; CURRVAL is {reason}.\n{ddl}'
+        rows = self.catalog.rows(
+            '''select to_char(increment_by, 'TM9'), to_char(min_value, 'TM9'), to_char(max_value, 'TM9'),
+                      cycle_flag, scale_flag, sharded_flag
                from all_sequences where sequence_owner = :owner and sequence_name = :name''',
-            owner=obj.owner, name=obj.name,
+            key=(), owner=obj.owner, name=obj.name,
         )
         if not rows:
             raise RuntimeError(f'{obj.label}: sequence metadata is no longer accessible')
@@ -312,11 +344,10 @@ class TableExportService:
         if scale == 'Y' or sharded == 'Y':
             return f'-- START WITH {saved} from metadata; SCALE/SHARD CURRVAL offsets require manual review.\n{ddl}'
         increment, minimum, maximum = int(increment), int(minimum), int(maximum)
-        restart = current + increment
-        if not minimum <= restart <= maximum:
-            if cycle != 'Y':
-                raise RuntimeError(f'{obj.label}: CURRVAL {current} has exhausted the sequence bounds')
-            restart = minimum if increment > 0 else maximum
+        try:
+            restart = sequence_restart_value(current, increment, minimum, maximum, cycle)
+        except CatalogUnavailable as exc:
+            raise RuntimeError(f'{obj.label}: {exc}') from exc
         ddl = ddl[:start.start(1)] + str(restart) + ddl[start.end(1):]
         return (f'-- START WITH {restart} from session CURRVAL {current} and INCREMENT BY {increment}'
                 f' (metadata START WITH {saved}).\n{ddl}')
@@ -331,7 +362,7 @@ class TableExportService:
         available_tables = set(self.tables(source))
         if not set(tables) <= available_tables:
             raise ValueError('A selected table disappeared or is no longer accessible; restart the export')
-        schema_objects = self.rows('select object_name, object_type from all_objects where owner = :owner', owner=source)
+        schema_objects = self.catalog.rows('select object_name, object_type from all_objects where owner = :owner', owner=source)
         known_names = {name for name, kind in schema_objects}
         known_objects = {ExportObject(source, name, _METADATA_TYPES.get(kind, kind)) for name, kind in schema_objects}
         package_bodies = {name for name, kind in schema_objects if kind == 'PACKAGE BODY'}
@@ -377,43 +408,51 @@ class TableExportService:
             table_obj = ExportObject(source, table, 'TABLE')
             progress(f'Reading dependencies: {table_obj.label}', completed_tables, len(included_tables))
             add_references(table_obj, self.table_dependencies(table_obj, known_objects))
-            for owner, name in self.rows(
+            key_indexes = set(self.catalog.rows(
+                """select index_owner, index_name from all_constraints where owner = :owner
+                   and table_name = :name and constraint_type in ('P','U') and index_name is not null""",
+                owner=source, name=table,
+            ))
+            for owner, name in self.catalog.rows(
                 """select i.owner, i.index_name from all_indexes i
                    where i.table_owner = :owner and i.table_name = :name
-                   and i.index_type not in ('LOB', 'IOT - TOP')
-                   and not exists (select 1 from all_constraints c where c.owner = :owner
-                     and c.table_name = :name and c.constraint_type in ('P','U')
-                     and c.index_owner = i.owner and c.index_name = i.index_name)""", owner=source, name=table,
+                   and i.index_type not in ('LOB', 'IOT - TOP')""", owner=source, name=table,
             ):
+                if (owner, name) in key_indexes:
+                    continue
                 obj = ExportObject(owner, name, 'INDEX')
                 refs = self.object_dependencies(obj) | {table_obj}
-                for (expression,) in self.rows(
+                for (expression,) in self.catalog.rows(
                     'select column_expression from all_ind_expressions where index_owner = :owner and index_name = :name',
                     owner=owner, name=name,
                 ):
                     if expression:
                         refs.update(self.expression_dependencies(expression, owner, known_objects))
                 add_references(obj, refs)
-            for owner, name, body in self.rows(
+            for owner, name, body in self.catalog.rows(
                 'select owner, trigger_name, trigger_body from all_triggers where table_owner = :owner and table_name = :name',
-                owner=source, name=table,
+                key=(0, 1), owner=source, name=table,
             ):
                 obj = ExportObject(owner, name, 'TRIGGER')
                 add_references(obj, self.trigger_dependencies(obj, body) | {table_obj})
-            for owner, name, ref_owner, ref_table in self.rows(
-                """select c.owner, c.constraint_name, c.r_owner, p.table_name
-                   from all_constraints c left join all_constraints p
-                     on p.owner = c.r_owner and p.constraint_name = c.r_constraint_name
+            for owner, name, ref_owner, ref_constraint in self.catalog.rows(
+                """select c.owner, c.constraint_name, c.r_owner, c.r_constraint_name
+                   from all_constraints c
                    where c.owner = :owner and c.table_name = :name and c.constraint_type = 'R'""",
-                owner=source, name=table,
+                key=(0, 1), owner=source, name=table,
             ):
+                parent = self.catalog.rows(
+                    'select table_name from all_constraints where owner = :owner and constraint_name = :name',
+                    key=(), owner=ref_owner, name=ref_constraint,
+                )
+                ref_table = parent[0][0] if parent else None
                 add_references(ExportObject(owner, name, 'REF_CONSTRAINT'), {
                     table_obj, ExportObject(ref_owner, ref_table or '<inaccessible referenced table>', 'TABLE'),
                 })
             completed_tables += 1
         dependencies = {ref for refs in references.values() for ref in refs}
         # Identity backing sequences are part of CREATE TABLE, never separate exports.
-        identities = {ExportObject(source, row[0], 'SEQUENCE') for table in sorted(included_tables) for row in self.rows(
+        identities = {ExportObject(source, row[0], 'SEQUENCE') for table in sorted(included_tables) for row in self.catalog.rows(
             'select sequence_name from all_tab_identity_cols where owner = :owner and table_name = :name',
             owner=source, name=table,
         )}
@@ -441,6 +480,7 @@ class TableExportService:
         self.check_cancelled()
         warnings = sorted(set(warnings))
         header = [
+            'SET DEFINE OFF',
             '-- Table DDL Export: definitions only; review before execution.',
             f'-- Source: {quote_identifier(source)}; target: {quote_identifier(target)}',
             f'-- {len(included_tables)} table(s), {len(sequence_objects)} sequence(s). Destination schema must already exist.',
@@ -452,6 +492,7 @@ class TableExportService:
             ' directly referencing package(s)/function(s)/procedure(s).',
             f'-- {sum(obj.kind == "VIEW" for obj in table_users)} directly referencing view(s).',
             '-- Definitions follow creation dependencies; cycles and external prerequisites are listed below.',
+            '-- Discovery prefers ALL_* catalogs, supplemented by accessible DBA_* views; invisible dependencies may be absent.',
             '-- Tablespaces/storage omitted. Sequence starts prefer session CURRVAL + increment, else metadata.',
             '-- CURRVAL is session-local; other sessions may have consumed different values.',
             '-- Restart positions are export-time snapshots; cache gaps may occur. No source NEXTVAL was called.',