Edit

Review tasks and output folders for Oracle to Azure Database for PostgreSQL flexible server schema conversion

After a schema conversion run, the Visual Studio Code PostgreSQL extension creates two types of output: review guidance and generated PostgreSQL schema files. Use this article to understand which files to open first, how to prioritize review tasks, and how to navigate the folder structure that the conversion tool creates.

This article focuses on schema conversion output. It doesn't cover data migration.

What the output helps you decide

The generated output helps different stakeholders answer different questions:

Question Start with
Is the converted schema ready for validation? reports/customer_summary.md.
Which items need human review? The Schema Review pane in the Visual Studio Code PostgreSQL extension.
Which generated SQL file maps to an Oracle object? postgres_ddl/<schema>/<object_type>/.
Why did a specific object need review? Open the task in the Schema Review pane and read its description and evidence. The related chunk report in reports/chunks/ provides extra context.
What should the deployment script run? deploy.sql.
What should I share with support for troubleshooting? reports/, internal/, and the relevant session metadata. Don't share credentials or secrets.

Start with the session folder

Each conversion run creates a session folder under the migration artifacts directory. The exact session ID changes for every run.

<project-root>/
  artifacts/
    oracle/
      _migration/
        convert/
          sessions/
            <session-id>/

Open reports/customer_summary.md inside the session folder first. It gives you the overall readiness decision and points you to the other reports, generated SQL, and review tasks for that run.

Review and resolve tasks in Visual Studio Code

A review task is a flagged item that needs human judgment before you use the converted schema. The tool creates review tasks when it detects behavior that you should verify, when it produces fallback DDL, or when it can't fully convert an object. Many tasks are validation reminders for differences between Oracle and PostgreSQL behavior, such as numeric precision, date and time handling, transaction control, exception handling, or schema resolution.

The Schema Review pane in the Visual Studio Code PostgreSQL extension is the primary place to triage and resolve these tasks. The pane offers two views:

  • Grouped. Tasks bundled by category. The categories that appear depend on the converted schema and can include items such as General, Numeric Semantics, Date/Time Behavior, Empty String / NULL, DBMS_OUTPUT, and NLS / Collation. Each group shows total tasks, how many need review, and how many are blocked, so you can plan remediation by theme.
  • Tasks. Individual tasks with filters for Status, Priority, Object Type, and Schema. Use this view to triage, assign, and resolve work item by item.

Switch between Pending and Resolved to track progress.

Screenshot of the Schema Review pane in the Visual Studio Code PostgreSQL extension showing the Grouped and Tasks views.

Task fields shown in the Tasks view

Column What it shows
Title Short description of the issue and the affected Oracle object.
Status Pending or Resolved.
Criticality Severity of the issue: Mandatory (High), Recommended (Medium), or Optional (Low).
Object Type The Oracle object type, such as Table, Index, Procedure, Function, Trigger, or View.
Description Evidence that explains why the tool flagged the object.
Actions Run Task opens GitHub Copilot agent mode with the task context for guided remediation. Resolve marks the task complete after manual review or after you accept the proposed fix.

Criticality levels

The tool assigns each review task a criticality level that maps to a priority:

Criticality Priority When to resolve
Mandatory High Resolve before deployment. The converted object isn't ready for production use until you address the task.
Recommended Medium Resolve before promoting the schema to production. The object can deploy, but the behavior should be validated against the Oracle source.
Optional Low Resolve when convenient. The task highlights a minor difference or improvement opportunity.

Resolve a task

You can resolve a review task in two ways:

  • With GitHub Copilot agent mode: Select Run Task to launch GitHub Copilot agent mode in Visual Studio Code with the source DDL, generated PostgreSQL DDL, and task evidence as context. Review the proposed fix, apply it, and then select Resolve.
  • Manually: Open the generated .sql file under postgres_ddl/<schema>/<object_type>/, apply your fix in Visual Studio Code, validate it in the scratch database, and then select Resolve.

Note

Resolving a review task updates the generated .sql file in postgres_ddl/, but the change isn't automatically applied to the scratch database. Connect to the scratch database from Visual Studio Code and run the updated .sql file to validate the fix before you mark the task as resolved.

Resolve Mandatory tasks first because they block deployment validation. Resolve Recommended tasks before promoting the schema to production, and address Optional tasks when convenient.

Review tasks workflow

Use this workflow after conversion completes:

  1. Open reports/customer_summary.md to understand the overall readiness decision.
  2. Open the Schema Review pane in Visual Studio Code, switch to Grouped, and resolve Mandatory tasks first.
  3. Switch to Tasks to filter, assign, and triage Recommended and Optional items.
  4. Inspect the generated PostgreSQL file for each task under postgres_ddl/<schema>/<object_type>/.
  5. Select Run Task to resolve the task with GitHub Copilot agent mode, or apply a manual fix and then select Resolve.
  6. Apply the updated .sql file to the scratch database and test the corrected object. Resolving a task doesn't auto-apply the change to the scratch database.
  7. Rerun conversion if you change the source scope, fix a source object, add missing target extensions, change search_path, or increase Microsoft Foundry capacity.

Output folder structure

The conversion project folder contains configuration files, extracted Oracle artifacts, conversion artifacts, generated PostgreSQL files, and application guidance. Folder names can vary slightly by extension version.

<project-root>/
  artifacts/
    oracle/
      _migration/
        extract/
          ddl/
          reports/
          internal/
        chunks/
          reports/
          internal/
        convert/
          sessions/
            <session-id>/
              deploy.sql
              reports/
                customer_summary.md
                technical_conversion_report.md
                review_tasks.md
                chunks/
              postgres_ddl/
                <schema>/
                  <object_type>/
              internal/
  results/
    application_guidance/

Extraction artifacts

The artifacts/oracle/_migration/extract/ folder contains the Oracle objects and reports captured during the extraction phase.

Folder or file Purpose
ddl/ Source Oracle DDL grouped by schema and object type.
reports/oracle_extraction_report.md Human-readable extraction summary.
reports/excluded_objects.csv Objects that the tool intentionally excluded.
reports/unsupported_types.csv Unsupported Oracle types or constructs found during extraction.
internal/ Metadata, dependency files, and logs used by the tool for troubleshooting.

Chunking artifacts

The artifacts/oracle/_migration/chunks/ folder shows how the tool grouped extracted objects into dependency-aware batches for conversion.

Folder or file Purpose
reports/chunk_generation_report.md Summary of the chunks, object distribution, dependencies, and token planning.
internal/ Metadata, dependency files, and logs used by the tool for troubleshooting.

Conversion artifacts

The artifacts/oracle/_migration/convert/sessions/<session-id>/ folder contains the primary conversion output for one run.

Folder or file Purpose
reports/customer_summary.md Executive-friendly readiness summary with conversion status and next actions.
reports/review_tasks.md Markdown copy of the review tasks for offline reference and audit. Resolve tasks from the Schema Review pane in Visual Studio Code.
reports/technical_conversion_report.md Detailed technical report for DBAs and migration engineers.
reports/chunks/ Per-chunk conversion reports for deeper investigation.
postgres_ddl/ Object-level Azure Database for PostgreSQL .sql files grouped by schema and object type.
deploy.sql Consolidated deployment script generated from the converted schema output.
internal/ Metadata, dependency files, and logs used by the tool for troubleshooting.

Application guidance

The results/application_guidance/ folder contains coding notes generated from the converted schema. Use these notes as input when you convert the application code that calls the converted schema. For example, you can use them when you adapt Oracle PL/SQL clients, ORMs, or stored-procedure callers to work with PostgreSQL.

Use object-level SQL files

Use the postgres_ddl/ folder when a review task points to a specific object. The folder structure groups files by Oracle schema and object type. When you convert more than one schema in the same run, each schema gets its own top-level folder under postgres_ddl/:

postgres_ddl/
  HR/
    TABLE/
    FUNCTION/
    PROCEDURE/
    TRIGGER/
    VIEW/
  SALES/
    TABLE/
    FUNCTION/
    PROCEDURE/
    TRIGGER/
    VIEW/

The extracted Oracle DDL under artifacts/oracle/_migration/extract/ddl/ follows the same <schema>/<object_type>/ layout.

Use generated prompts carefully

Some review tasks include a GitHub Copilot prompt that contains source DDL, generated PostgreSQL DDL, evidence, and suggested actions. Use these prompts to speed up investigation, but review the content before you paste it into any chat or support workflow. Follow your organization's policy for sharing schema names, object names, and business logic.

Share the right artifacts with stakeholders

Use different artifacts for different audiences:

Audience Share
Project sponsors and business stakeholders reports/customer_summary.md and a summary of blocked or review items.
DBAs and migration engineers The Schema Review pane in Visual Studio Code (or reports/review_tasks.md for offline review), reports/technical_conversion_report.md, postgres_ddl/, and deploy.sql.
Application teams Review tasks for procedures, functions, triggers, packages, views, and application-facing tables, triaged from the Schema Review pane.
Support teams The reports, relevant logs, and the task ID or object name. Remove credentials and secrets before sharing.

Related content

  • Last updated on