1z0-931-25 Oracle Autonomous Database Cloud 2025 Professional Free Practice Exam Questions (2025 Updated)

A refreshable clone in Autonomous Database is a read-only copy of a source database that syncs periodically, but it has a refresh time limit (typically 7 days). Once this limit is exceeded, specific actions are available. The two correct options are:

You can disconnect from the source to make the database a read/write database (B):After the refresh time limit passes, the clone can no longer sync with the source. You can “disconnect” it (via the OCI console or API, e.g., oci db autonomous-database update --is-refreshable-clone false), converting it into an independent, read/write Autonomous Database. This requires a new license and incurs full costs, but it allows modifications (e.g., INSERT or UPDATE) that were blocked in read-only mode. For example, a test clone might be disconnected to become a production instance after testing.

You can use the instance as a read-only database (C):Even after the refresh limit, the clone remains functional as a read-only database, retaining its last refreshed state. You can query it (e.g., SELECT * FROM sales) for analysis or reporting without further refreshes, though it won’t reflect source updates. This is useful if ongoing read-only access suffices without needing write capabilities.

The incorrect options are:

You can manually refresh the clone (A):False. Once the refresh time limit (e.g., 7 days) is exceeded, manual refreshes are not possible. The clone’s refresh capability expires, and it can’t sync again unless recreated. This is a fixed constraint to manage resource usage in ADB.

You can extend the refresh time limit (D):False. The refresh period (set during clonecreation, max 7 days) cannot be extended after provisioning. You’d need to create a new clone with a longer limit if needed, but post-expiry, no extension is allowed.

These options provide flexibility post-expiry, balancing read-only continuity and full database conversion.

Full Detailed In-Depth Explanation:

Supported events:

A:True. Marks the start of maintenance.

B:False. Not a recognized event type.

C:True. Indicates compartment change start.

D:False. IORM updates are internal, not event-tracked.

E:True. Signals termination completion.

ADW and ATP are tailored for different workloads:

Correct Answer (C): “Only ADW uses columnar compression by default” is true. ADW employs Hybrid Columnar Compression (HCC) for analytics, optimizing storage and query performance, while ATP uses row-based storage for transactional workloads (though HCC can be enabled manually).

Incorrect Options:

A: Both ADW and ATP manage optimizer statistics automatically.

B: Autoscaling is supported by both ADW and ATP.

Manual backups in Autonomous Database are stored in OCI Object Storage, and the bucket name follows a strict convention. The correct name is:

BACKUP_DBSRV1 (D):For manual backups, ADB uses a bucket named BACKUP_ (all uppercase). Here, DBSRV1 is the database’s unique name (not the display name PRODDB), so the bucket must be BACKUP_DBSRV1. This bucket is automatically created by Oracle when you initiate a manual backup via the OCI console (e.g., “Create Manual Backup” button) or API (e.g., oci db autonomous-database backup create). For example, backing up DBSRV1 on March 18, 2025, stores files like backup_DBSRV1_20250318.dmp in this bucket. The unique name ensures uniqueness across the tenancy, as display names (e.g., PRODDB) might not be unique but the DB_UNIQUE_NAME is system-assigned and distinct.

The incorrect options are:

backup_proddb (A):This uses the display name proddb and lowercase, violating the BACKUP_ uppercase convention.

BACKUP_PRODDB (B):While uppercase, it uses the display name PRODDB, not the unique name DBSRV1, so it’s incorrect. Display names are for human readability, not system identification.

backup_dbsrv1 (C):This uses lowercase and lacks the exact BACKUP_ prefix format, failing Oracle’s naming rule.

The rigid naming ensures consistency and automation in ADB’s backup system.

Configuring private endpoints for Autonomous Database involves network security rules. The false statement is:

A stateless ingress rule is created to allow connections from the source to the Autonomous Database instance (C):This is incorrect. For Autonomous Database private endpoints, security rules (e.g., in Security Lists or NSGs) must be stateful, not stateless. Stateful rules track connection states (e.g., allowing return traffic automatically), which is necessary for Oracle Net Services (SQL*Net) communication over TCP. A stateless rule requires explicit ingress and egress rules for both directions, complicating setup and risking connectivity issues. For example, a stateful ingress rule from a client subnet (e.g., 10.0.1.0/24) to the ADB subnet ensures bidirectional traffic works seamlessly without additional egress rules.

The true statements are:

The IP Protocol is set to TCP (A):Autonomous Database uses TCP for database connections, aligning with Oracle Net Services standards.

The destination port range is set to 1522 (B):Port 1522 is the default for secure TLS connections to Autonomous Database, as specified in the client wallet’s tnsnames.ora.

The source is set to the address range you want to allow to connect to your database (D):The security rule defines the source CIDR block (e.g., 10.0.0.0/16) of allowed clients, restricting access to specific subnets or VCNs.

Stateful rules simplify and secure private endpoint configurations.

Private endpoints enhance security for Autonomous Database:

Correct Answer (A): “A Network Security Group is required within your Virtual Cloud Network before you can provision a shared Autonomous Database to use private endpoints” is true. An NSG is mandatory to define ingress/egress rules for the private subnet hosting the endpoint.

Correct Answer (C): “Private endpoints can be configured when you clone a shared Autonomous Database that was initially created with public endpoints” is true. Cloning allows switching to a private endpoint configuration.

Incorrect Options:

B: Private endpoints are inaccessible from the public internet, even with ACLs; that’s their purpose.

Full Detailed In-Depth Explanation:

Autonomous Database on Dedicated Infrastructure comprises:

Autonomous Exadata Infrastructure:The hardware and software foundation.

Autonomous Container Database:Hosts multiple ADB instances.

Autonomous Database:The managed database instance.

Autonomous Backup:Automatic backups to OCI Object Storage.

Other options include roles (B, C) or general OCI resources (D), not core components of the service. A is the correct composition.

Oracle APEX (Application Express) in Autonomous Database requires a workspace for development:

Correct Answer (A): “Access the APEX Administrator Services and create the workspace for the developer” is the correct step. As an admin, you log into the APEX Administration Services (via Database Actions or a direct URL), navigate to “Manage Workspaces,” and create a new workspace, assigning it to the developer with a schema and credentials.

Incorrect Options:

B: Creating an IDCS (Identity Cloud Service) user with an APEX role manages authentication but doesn’t create a workspace.

C: A database user with an APEX role lacks a workspace; it’s a prerequisite step, not the solution.

Autonomous Transaction Processing (ATP) provides predefined connection services to optimize different workload types. For a high-concurrency OLTP application with parallel reporting queries, the appropriate service is:

HIGH (C):The HIGH connection service in ATP is designed for workloads requiring high concurrency and throughput, making it ideal for a production OLTP application like "EXAM" that handles many simultaneous transactions (e.g., user requests). Additionally, HIGH supports parallel query execution, which is critical for running reporting queries efficiently during off-peak times. It allocates more resources (e.g., OCPUs and I/O) compared to other services, ensuring performance for both transactional and analytical tasks. For example, the OLTP app might use HIGH to process thousands of concurrent user requests, while a nightly report leverages parallel processing to aggregate data quickly. In the wallet’s tnsnames.ora, the HIGH service might look like exam_high = (DESCRIPTION=...), offering the best balance for this mixed workload.

The incorrect options are:

TPURGENT (A):The TPURGENT service prioritizes low-latency, time-critical transactions (e.g., sub-second response times for single-user actions). It’s optimized for latency-sensitive operations, not high concurrency or parallel reporting, and would underperform for the broader OLTP and reporting needs here. For instance, it’s better suited for a single critical transaction than a multi-user system.

TP (B):The TP (Transaction Processing) service is a general-purpose option for OLTP workloads, offering moderate concurrency and latency. However, it’s not optimized for high concurrency or parallel query execution, making it less suitable for a production app with reporting demands. It’s a middle ground, not a top-tier performer like HIGH.

MEDIUM (D):The MEDIUM service balances performance and resource usage for moderate workloads. It supports some concurrency but lacks the resource allocation and parallel execution capabilities of HIGH, making it inadequate for a high-concurrency OLTP system with reporting requirements.

The HIGH service’s ability to handle both high transactional volume and parallel reporting aligns perfectly with the scenario’s strict performance needs, all within ATP’s zero-maintenance framework.

Creating an Autonomous Database offers specific deployment options. The two correct ones are:

APEX Service on Dedicated Infrastructure (A):This option provisions an Autonomous Database on dedicated Exadata infrastructure with Oracle Application Express (APEX) pre-installed and optimized. It’s ideal for APEX-based apps (e.g., custom web forms) requiring isolated resources. In the OCI console, you select “Dedicated Infrastructure” and “APEX Service” as the workload type, specifying OCPUs and storage. For example, a company might deploy an APEX app for internal reporting on a dedicated ACD, ensuring performance isolation from other tenants.

Autonomous JSON Database on Shared Infrastructure (C):This creates a schema-less, JSON-centric ADB on shared infrastructure, optimized for document storage (e.g., { "order_id": 123, "items": [...] }). It’s provisioned via the OCI console under “Shared Infrastructure,” selecting “JSON Database” as the workload type. For instance, a mobile app might use it to store user data, leveraging SQL/JSON queries like SELECT JSON_VALUE(doc, '$.order_id'). It’s cost-effective and fully managed, sharing Exadata resources.

The incorrect options are:

APEX Service on Shared Infrastructure (B):There’s no distinct “APEX Service” workload type on shared infrastructure. APEX is available within ATP or ADW on shared infra, but it’s not a standalone option—you’d provision ATP and enable APEX manually, not as a dedicated “APEX Service.”

Autonomous JSON Database on Dedicated Infrastructure (D):JSON Database is onlyoffered on shared infrastructure, not dedicated. Dedicated options include ATP, ADW, and APEX Service, but JSON Database leverages shared resources for simplicity and cost.

These options cater to specific app development (APEX) and NoSQL (JSON) needs.

Oracle Autonomous JSON Database is a specialized variant of Autonomous Database. The correct workload is:

Schema-less, document-centric (D):Autonomous JSON Database is designed for applications needing flexible, schema-less data storage and retrieval, particularly JSON documents. It’s a NoSQL-style database optimized for document-centric workloads, such as web or mobile apps storing user profiles, IoT data, or content management systems. For example, a social media app might store user posts as JSON documents { "user": "John", "post": "Hello world" }, allowing dynamic field additions without schema changes. It supports SQL/JSON queries (e.g., SELECT JSON_VALUE(doc, '$.user')), blending relational and NoSQL benefits, and auto-manages indexing for performance.

The incorrect options are:

Data Marts (A):Data marts are structured, analytical stores for aggregated data, better suited to Autonomous Data Warehouse (ADW), which excels at columnar storage and complex queries, not JSON’s flexible format.

Transactions (B):Traditional OLTP transactions (e.g., banking records) are the domain of Autonomous Transaction Processing (ATP), which uses rigid schemas for consistency, unlike JSON Database’s schema-less approach.

Data Lakes (C):Data lakes store raw, mixed-format data (e.g., JSON, CSV, Parquet) for later processing, typically in object storage, not a managed database like Autonomous JSON. While JSON Database handles JSON, it’s not a data lake replacement.

This workload leverages JSON Database’s agility for modern, unstructured data applications.

Autonomous Database on Dedicated Infrastructure provides unique metrics due to its Exadata underpinnings:

Correct Answer (C): “IOPS, Storage used by tablespace, Apply and Transport Lag” are specific to dedicated deployments:

IOPS: Measures input/output operations per second, reflecting Exadata storage performance.

Storage used by tablespace: Tracks storage allocation at the tablespace level, unique to dedicated infrastructure’s granular control.

Apply and Transport Lag: Relevant for Data Guard configurations, showing replication delays, available only in dedicated setups with standby databases.

Incorrect Options:

A: Transaction Count, Running Statements, and Sessions are general metrics available in both shared and dedicated environments.

B: CPU and Storage Utilization are standard across all Autonomous Database types.

Fleet administrators manage resource utilization in Autonomous Database on Dedicated Infrastructure:

Correct Answer (B):Compartment quotasare used to set limits on OCPU usage across multiple database instances within a compartment. This OCI feature allows administrators to define maximum resource allocations, ensuring efficient use and cost control at a tenancy level.

Incorrect Options:

A: Oracle Machine Learning notebooks are for analytics, not resource control.

C: SQL Developer Web Console manages individual database tasks, not fleet-wide OCPU limits.

Creating an Autonomous Transaction Processing (ATP) database via OCI CLI requires specific parameters:

Correct Answer (A): db-type is not a standard OCI CLI parameter for provisioning an Autonomous Database. The CLI uses parameters like db-workload to specify the type (e.g., ATP).

Used Parameters:

B: is-dedicated must be set to false for shared infrastructure.

C: db-workload is set to OLTP for ATP.

Setting up notifications for scheduled shutdowns leverages OCI Events:

Correct Answer (A): Creating a rule for the 'Autonomous Database STOP END' event in OCI Events triggers a notification (e.g., email via Notification Service) when the shutdown completes. This is the recommended method for tracking lifecycle events in Autonomous Database.

Incorrect Options:

B: There is no specific “Shutdown” metric in OCI Metrics; alarms monitor performance metrics, not lifecycle events like shutdowns.

C: Database triggers like BEFORE SHUTDOWN are not supported in Autonomous Database due to its managed nature, and they wouldn’t integrate with OCI notifications.

Oracle Cloud Infrastructure (OCI) Identity and Access Management (IAM) defines four verb levels for policy permissions:

Read (B): Allows viewing resource details without modification (e.g., read autonomous-databases).

Manage (C): Permits full control, including creating, updating, and deleting resources (e.g., manage autonomous-databases).

Inspect (D): Enables listing resources and basic metadata without detailed access (e.g., inspect autonomous-databases).

Use (E): Allows interaction with resources (e.g., connecting to a database) without altering their configuration.

Incorrect Option:

Disabling Autonomous Data Guard affects the standby database:

Correct Answer (A): “The standby database is terminated” is true. When Data Guard is disabled via the OCI Console or API, the standby database is deleted, ending its role as a replica. This is a permanent action requiring re-enablement to recreate a standby.

Incorrect Options:

B: The standby doesn’t become read-write; it’s removed entirely.

C: It doesn’t remain read-only; termination stops all operations.

Autonomous Database supports multiple methods for loading data, tailored to its cloud-managed nature. The three correct methods are:

Oracle Data Pump (A):Data Pump is a versatile tool for importing data into Autonomous Database. You export data from a source database (e.g., using expdp), upload the dump files to OCI Object Storage, and then use the DBMS_CLOUD package (e.g., DBMS_CLOUD.COPY_DATA) to import it. It’s ideal for bulk data migration, supporting complex schemas and large datasets. For example, a DBA might export a schema from an on-premises database, upload it to a bucket, and import it into ADB with minimal downtime.

Oracle GoldenGate (C):GoldenGate enables real-time data replication from sourcedatabases (on-premises or cloud) to Autonomous Database. It’s perfect for continuous data loading or synchronization, supporting both initial loads and ongoing change data capture. For instance, you could replicate transactional data from an OLTP system to ADB using GoldenGate’s CDC (Change Data Capture) capabilities, ensuring near-zero latency.

SQL*Loader (E):SQL*Loader loads data from flat files (e.g., CSV, text) into Autonomous Database. You upload files to OCI Object Storage and use DBMS_CLOUD procedures (e.g., DBMS_CLOUD.LOAD_DATA) to process them. It’s efficient for structured data imports, like loading a CSV of customer records, with options to handle errors and transformations.

The incorrect options are:

RMAN Restore (B):Recovery Manager (RMAN) is for backups and restores, not general data loading. While it can restore an ADB from a backup, it’s not a method for loading new data into an existing instance.

Transportable Tablespace (D):This method moves tablespaces between databases by copying data files, but it’s not supported in Autonomous Database due to its managed architecture, which restricts direct file-level operations.

These methods cater to different use cases: Data Pump for migrations, GoldenGate for replication, and SQL*Loader for file-based loads.

In Oracle Cloud Infrastructure (OCI), the Notifications service is used to send messages (e.g., via email, SMS, or HTTP endpoints) to subscribers. The correct terminology for the communication channel is:

Topic (C):A "topic" in OCI Notifications is the named entity that acts as a communication channel. Publishers send messages to a topic, and subscribers (e.g., email addresses, SMS numbers, or custom endpoints) receive those messages based on their subscription to that topic. For example, you might create a topic called "DatabaseAlerts" to send notifications about database events. When a message is published to this topic, all subscribed endpoints (e.g., an email like user@example.com) receive it. This design follows a publish-subscribe (pub/sub) model, making "topic" the central concept for message distribution.

The incorrect options are:

Subject (A):The "subject" is a field within a message (e.g., the subject line of an email), not the channel itself. It describes the content of an individual notification but doesn’t define the mechanism for sending it. For instance, an email notification might have a subject like "Database Maintenance Scheduled," but the topic is the channel delivering it.

Notification (B):A "notification" refers to the actual message being sent (the payload), not the channel through which it travels. It’s the output of the process, not the infrastructure enabling it. For example, a notification might be "Database is down," but it’s sent via a topic.

Event (D):An "event" is an occurrence or trigger (e.g., a database failover) that might generate a notification, but it’s not the channel. Events are inputs that can be monitored by services like OCI Events, which then publish to a topic in Notifications.

The use of "topic" aligns with OCI’s architecture for scalable, decoupled messaging. To illustrate, you’d create a topic in the OCI console under "Notifications," configure subscriptions (e.g., email or SMS), and then use APIs or triggers to publish messages to it. This abstraction ensures flexibility and reliability in message delivery across various protocols.