Creating Online-Patching-Compliant Table in Oracle E-Business Suite R12.2

Online patching introduced in Oracle E-Business Suite R12.2 fundamentally changed the way custom objects must be created and maintained. To ensure zero-downtime patching, every custom table must support Edition-Based Redefinition (EBR). This requires a base table, an editioning view, and an APPS synonym—created in a specific sequence using Oracle’s AD_ZD utilities.

This article provides a clear, step-by-step guide to creating an online-patching-compliant table along with its editioning view (EV) in R12.2. It also outlines how to manage future structural changes through XDF metadata or AD_ZD utilities.


1. Create the Base Table in the Owning Schema

Begin in the Run edition, logged in as the appropriate product schema (for example, APPLSYS or a custom application schema).
At this stage, only the base database objects are created.

Typical actions include:

  • Creating the table using standard DDL.

  • Defining supporting indexes.

  • Using APPS_TS_* tablespaces depending on the object type.

  • Preferring unique indexes instead of primary key constraints, in line with R12.2 object standards.

At this point, no editioning view exists. The table is still non-compliant with online patching.


2. Upgrade the Table to Create the Editioning View and APPS Synonym

Once the base table is ready, convert it into an online-patching-aware object using Oracle’s AD_ZD package:

EXEC AD_ZD_TABLE.UPGRADE('<OWNER_SCHEMA>', '<TABLE_NAME>');

This action generates two critical components:

  • Editioning View (EV):
    Created in the owning schema with the name <TABLE_NAME>#.
    This view becomes the layer through which the application interacts with the table.

  • APPS Synonym:
    A synonym named <TABLE_NAME> is created in the APPS schema, pointing to the EV.

From this point forward, all application components—Forms, OAF, PL/SQL APIs, reports—must reference the APPS synonym. This ensures that future table changes are transparently managed through the EV without breaking online patching rules.


3. Generate and Deploy the XDF Metadata

To package this custom table for deployment across environments, Oracle requires an XDF (XML Definition File) representation.

Steps:

  1. Insert at least one row into the new table (mandatory for XDF generation).

  2. Run xdfgen.pl from the Run edition to produce the .xdf file containing the metadata for the table, indexes, and associated objects.

  3. Include this .xdf in your custom application patch.

  4. During patch application, xdfcmp.pl automatically creates the base table and invokes AD_ZD_TABLE.UPGRADE, ensuring that the EV and APPS synonym are generated in all target instances.

This makes your object fully compliant with the R12.2 adoption and deployment model.


4. Managing Future Structural Changes

When enhancements or structural modifications are required—such as adding new columns—you must preserve online patching compliance.

Two methods are supported:

a. Preferred Method: Update via XDF

Modify the XDF file and apply it using xdfcmp.pl.
This ensures consistent behavior across environments and adheres to Oracle's standards.

b. Direct DDL in Development

If a table is altered manually in a development instance:

EXEC AD_ZD_TABLE.PATCH('<OWNER_SCHEMA>', '<TABLE_NAME>');

This regenerates the EV mapping to align it with the updated table structure.


Conclusion

Building online-patching-compliant objects is essential for long-term maintainability in Oracle E-Business Suite R12.2. By creating the base table, generating the editioning view through AD_ZD utilities, and managing future changes via XDF or AD_ZD_TABLE.PATCH, you ensure seamless behavior during both Run and Patch editions.


Understanding Oracle Unified Auditing: Quick Checks for DBAs


Oracle Unified Auditing consolidates all audit records into a single, unified framework, simplifying how auditing is configured, managed, and reviewed. As more environments move toward stricter compliance and security standards, DBAs increasingly rely on Unified Auditing to track database activity efficiently.

This short guide highlights how to quickly check whether Unified Auditing is enabled and how to review the audit policies configured in your database.


✅ How to Check if Unified Auditing Is Enabled

Unified Auditing can run in two modes:

  • Mixed Mode (default)

  • Pure Unified Auditing Mode

To verify the status, check the database options:

SELECT VALUE FROM V$OPTION WHERE PARAMETER = 'Unified Auditing';
  • TRUE → Unified Auditing is enabled

  • FALSE → Unified Auditing is disabled

If the database is running in pure mode, it was enabled during installation or via relinking.


View Enabled Unified Audit Policies

To see which audit policies are currently active:

SELECT DISTINCT policy_name 
FROM audit_unified_enabled_policies;

This lists all enabled policies, including Oracle-supplied and user-defined ones.


View All Available Unified Audit Policies

To list every policy defined in the system:

SELECT DISTINCT policy_name 
FROM audit_unified_policies;

This helps you understand what policies exist, even if they’re not currently enabled.


Check Audit Options Associated with Each Policy

To see which audit options belong to each policy:

SELECT audit_option, policy_name 
FROM audit_unified_policies 
GROUP BY policy_name, audit_option;

This provides insight into what actions are being audited under each policy.


Summary

Oracle Unified Auditing centralizes and simplifies auditing. With just a few queries, DBAs can quickly validate:

  • Whether Unified Auditing is active

  • Which policies are enabled

  • What audit actions are tied to each policy

These checks are essential for maintaining security, ensuring compliance, and understanding the audit footprint of your Oracle environment.

Validating an Oracle TDE Wallet Password Safely with mkstore

When managing Oracle Transparent Data Encryption (TDE), it’s often necessary to verify whether a wallet password is correct—especially before performing operations such as opening the wallet, rotating keys, or restoring backups. The safest way to do this is by using the mkstore utility outside the database environment, without requiring any database open/close actions.

Below is a simple and secure method to validate your TDE wallet password.


Why Use mkstore for Validation?

mkstore allows you to test the wallet password independently of the database.
This approach ensures:

  • No impact on the running database

  • No wallet state changes

  • A direct and reliable password validation method


 Steps to Validate a TDE Wallet Password

1. Copy Only the ewallet.p12 File

Copy the wallet file (ewallet.p12) to a temporary directory:

  • Do not copy cwallet.sso
    The .sso file enables auto-login, which bypasses the password prompt.
    Excluding it ensures that mkstore must ask for the password.

Example:

cp /path/to/original/ewallet.p12 /tmp/wallet_validation/

2. Run the mkstore Command

From the Oracle home bin directory, execute:

mkstore -wrl <wallet_directory> -list

Replace <wallet_directory> with the path to your copied wallet (e.g., /tmp/wallet_validation/).

mkstore will prompt you to enter the wallet password.


3. Interpret the Result

  • Valid Password:
    The command displays wallet contents (aliases/entries).

  • Invalid Password:
    You will see an error indicating that the password is incorrect.

This method confirms the correctness of your TDE wallet password without any risk to the running database or the original wallet.


Why Avoid Copying cwallet.sso?

cwallet.sso enables auto-login mode.
If present, the wallet opens automatically and no password check occurs, defeating the purpose of validation.
By copying only ewallet.p12, you ensure that mkstore enforces password authentication.


Example Commands

cp /u01/app/oracle/admin/db_wallet/ewallet.p12 /tmp/wallet_validation/
mkstore -wrl /tmp/wallet_validation/ -list

๐ŸŸฉ Summary

Validating a TDE wallet password using mkstore is:

  • Safe

  • Non-intrusive

  • Independent of database state

  • Ideal before sensitive operations like wallet open, key changes, or backup restores

This simple check can help prevent downtime and errors related to incorrect wallet passwords.

Edition-Based Redefinition (EBR) in Action: Resolving Synonym Translation Errors

While working with Oracle Applications schemas, you may encounter the error ORA-00980: synonym translation is no longer valid when accessing editioning views or objects through a synonym. This article explains a practical example of how this issue arises and how to resolve it.


Scenario

A user TEST tried to access the APPS schema object FND_USER_RESP_GROUPS_DIRECT using a synonym.

SQL> SHOW USER
USER is "TEST"

The user then connected and created a synonym for the editioning view:

SQL> CONN test/***
Connected.

SQL> CREATE OR REPLACE SYNONYM "FND_USER_RESP_GROUPS_DIRECT" FOR APPS.FND_USER_RESP_GROUPS_DIRECT;

Synonym created.

However, when querying the synonym, the following error occurred:

SQL> SELECT COUNT(1) FROM FND_USER_RESP_GROUPS_DIRECT;
SELECT COUNT(1) FROM FND_USER_RESP_GROUPS_DIRECT
                     *
ERROR at line 1:
ORA-00980: synonym translation is no longer valid

Root Cause

This issue happens because the TEST user is not edition-enabled, while the target object in the APPS schema is an editioning view.
Edition-based redefinition (EBR) in Oracle allows for multiple versions of application objects (like packages and views) across different editions.
When a non-editioned user tries to access editioned objects, Oracle cannot resolve the synonym, leading to this error.

To verify the editioning status of the user:

SQL> SELECT EDITIONS_ENABLED FROM DBA_USERS WHERE USERNAME='TEST';

E
-
N

The result N indicates the user is not edition-enabled.


Resolution

Enable editions for the user to allow access to editioned objects:

SQL> ALTER USER test ENABLE EDITIONS;

User altered.

Confirm the change:

SQL> SELECT EDITIONS_ENABLED FROM DBA_USERS WHERE USERNAME='TEST';

E
-
Y

Reconnect as the user and retry the query:

SQL> CONN test/***
Connected.

SQL> SELECT COUNT(1) FROM FND_USER_RESP_GROUPS_DIRECT;

  COUNT(1)
----------
     18916

The query now executes successfully.


Key Takeaway

When creating synonyms for editioning views in Oracle E-Business Suite or any EBR-enabled schema, ensure that the referencing user has editioning enabled.
Otherwise, Oracle will fail to translate the synonym, resulting in the ORA-00980 error.


Oracle AI Database 26ai – What It Means for Oracle E-Business Suite

At Oracle AI World 2025 in Las Vegas, Larry Ellison announced the launch of Oracle AI Database 26ai (26ai) — the next evolution of Oracle Database, bringing AI-driven capabilities into the core database engine. This announcement marks a key milestone for both the Oracle Database and Oracle E-Business Suite (EBS) communities.


๐Ÿ”‘ Key Highlights from the Announcement

  • New Naming Convention: Oracle Database is now officially referred to as the Oracle AI Database.

  • 26ai Replaces 23ai: Oracle AI Database 26ai supersedes Oracle Database 23ai, becoming the latest long-term release.

  • No Architectural Changes: DB 26ai builds on 23ai with no changes to the internal architecture or APIs.

  • Smooth Transition:

    • If you’re on Oracle Database 23ai, simply apply the October 2025 Database Release Update (DBRU).

    • If you’re on 19c or earlier, a standard upgrade is required to move to 26ai.

  • Updated Documentation: Oracle’s database documentation and release materials now reference DB 26ai instead of DB 23ai.

  • New Release Numbering: Oracle has updated its database release numbering with the introduction of 26ai.

For detailed platform availability, refer to:
๐Ÿ“˜ Release Schedule of Current Database Releases (Doc ID 742060.1)


๐Ÿ’ก Impact on Oracle E-Business Suite

For Oracle E-Business Suite (EBS) customers:

  • All EBS documentation will be updated to replace mentions of “Oracle Database 23ai” with “Oracle AI Database 26ai.”

  • During this transition, you may see references to both names in parallel, but once updates are complete, only Oracle AI Database 26ai will appear across official documentation.


Oracle AI Database 26ai represents the next step in integrating AI-driven performance, automation, and insight into Oracle’s enterprise database platform—ensuring that EBS customers can continue to innovate with a future-ready, AI-enhanced foundation.



How to Safely Remove Sensitive Data Before Sharing Diagnostic Files with Oracle Support

When working with Oracle Support, customers often upload diagnostic files (such as logs, trace files, or exports) to assist in troubleshooting issues. However, these files may occasionally contain sensitive or confidential information.

Oracle provides clear guidance on how to review and sanitize such files before submission to ensure compliance and data privacy.


๐Ÿ” Key Recommendations

  • Review Before Uploading:
    Oracle’s Global Customer Support (GCS) does not automatically collect Personally Identifiable Information (PII). Customers should review all diagnostic output before uploading it through My Oracle Support (MOS).

  • Avoid Restricted File Types:
    Files with extensions like .exe, .com, .bat, and .aspx are not accepted by Oracle’s upload systems. Such files should be removed or archived (e.g., .zip, .tar, or .gzip) before resubmission.

  • Editable File Types:
    Files such as .trc, .log, .txt, .sql, .xml, .doc, and .xls can be opened in standard text or office editors to manually remove sensitive portions.

  • Non-Editable Formats:
    Files generated by tools like Documaker, or compressed binary files (e.g., .dpa, .pdf, .met, .pcl) may not be editable. Any personal data should be scrubbed before creating such files.

  • Using ADR and RDA Data:

    • ADR packages: Remove specific files before packaging via Enterprise Manager → Support Workbench.

    • RDA files: Review .rda, .htm, or .txt outputs with a text editor to redact confidential sections.


๐Ÿงฉ Why This Matters

Protecting sensitive data during support interactions safeguards both organizational security and customer trust. Oracle’s documentation emphasizes that customers retain full control and responsibility for what data is shared with Support.

By following these simple steps, organizations can ensure that only the necessary, sanitized information is sent to Oracle — keeping diagnostic collaboration secure and compliant.


๐Ÿ“˜ Reference:
Oracle Support Document ID 1227943.1How to Edit Output from Oracle Tools and Utilities to Remove Sensitive Content

Understanding Profile Option Values in Oracle E-Business Suite R12

In Oracle E-Business Suite R12, administrators often query the table FND_PROFILE_OPTION_VALUES to check profile settings at the user, responsibility, or site level. However, many times the VALUE column displays a lookup code instead of a readable description — making it hard to interpret.


For example if you query "FND: Debug Log Level" for user or site level from backend, it shows some numeric value.

Let’s look at how to find the actual meaning behind those coded values.


๐Ÿงฉ Step 1: Identify the Lookup Type

  1. Log in to EBS using the Application Developer responsibility.

  2. Navigate to:
    Profiles → System → Query the Profile Option -"AFLOG_LEVEL" (using its short name).

  3. In the results, note down the Lookup Type associated with that profile.


๐Ÿง  Step 2: Query the Lookup Meaning

Once you know the Lookup Type, use the following SQL query to decode the meaning: 

SELECT lookup_code,
       meaning,
       description
FROM   fnd_lookup_values
WHERE  lookup_type = 'AFLOG_LEVELS';


๐Ÿงพ Example

If a profile option value shows as ‘3’ or ‘4’ in FND_PROFILE_OPTION_VALUES, the above query helps you find out what those codes actually represent (for example, Statement or Exception).


✅ Summary

When you see cryptic values in FND_PROFILE_OPTION_VALUES, remember:

  • Use the Application Developer responsibility to find the Lookup Type.

  • Query FND_LOOKUP_VALUES to get the actual meaning.

This simple approach helps DBAs and support teams interpret configuration settings accurately — ensuring smoother troubleshooting and configuration validation.