Oracle 1z0-931-25 Oracle Autonomous Database Cloud 2025 Professional Exam Practice Test

Autonomous Data Warehouse (ADW) and Autonomous Transaction Processing (ATP) are optimized for different workloads, reflected in their configurations. The two differing optimizations are:

Memory Usage (A):ADW and ATP allocate memory differently to suit their purposes. ADW prioritizes a larger data cache (part of the SGA) to keep more data in memory, boosting analytical query performance (e.g., aggregations over millions of rows). For example, a SELECT SUM(sales) GROUP BY region runs faster with more cached data. ATP, conversely, balances memory across the SGA and PGA for transactional workloads, emphasizing concurrency and quick row-level operations (e.g., UPDATE orders SET status = 'shipped'). This difference ensures ADW excels at scan-heavy analytics, while ATP handles high-throughput updates.

Data Organization (B):ADW uses a columnar storage format (e.g., Hybrid Columnar Compression) optimized for analytics, storing data by column to speed up aggregations and reduce I/O (e.g., scanning only the sales column for a SUM). ATP uses a row-based format suited for OLTP, enabling fast single-row access and updates (e.g., retrieving or modifying a specific order_id). For instance, inserting a row in ATP is efficient due to row storage, while ADW’s columnar format accelerates SELECT AVG(price) FROM products.

The incorrect options are:

Backup Retention (C):Both ADW and ATP use the same automatic backup system (via Oracle’s Automatic Workload Repository), with a default 60-day retention adjustable by users. There’s no optimization difference here; it’s a shared managed feature.

Undo Management (D):Both databases use Oracle’s Flashback technology for undo (e.g., rolling back transactions or querying past states), with retention periods set similarly. Undo is managed automatically in both, not optimized differently.

These optimizations tailor ADW for analytics and ATP for transactions, despite their shared autonomous foundation.

Restricting access to an Autonomous Database to specific IPs involves network security controls. The correct answer is:

Access Control List (C):In Autonomous Database, an Access Control List (ACL) defines which IP addresses or CIDR blocks (e.g., 192.168.1.0/24) can connect to the database. You configure this via the OCI console under the ADB’s “Access Control List” settings, adding rules like “Allow TCP from 10.0.0.0/16 on port 1522.” This applies to public endpoints (shared infrastructure) or private endpoints with additional network rules, ensuring only authorized IPs can initiate connections. For example, a company might restrict access to its office VPN range, blocking all other traffic. ACLs work at the database level, complementing VCN security.

The incorrect options are:

Security List (A):Security Lists operate at the VCN subnet level, controlling traffic to all resources in the subnet (e.g., ingress TCP 1522 to an ADB subnet). While useful, they’re broader than ADB-specific ACLs, which target the database instance directly, making ACLs the precise answer here.

IP Vault (B):There’s no “IP Vault” in OCI. This might confuse OCI Vault (for secrets), but it doesn’t manage IP access.

IPSec List (D):IPSec secures traffic via VPNs, not IP allowlisting for database access. It’s unrelated to ADB connectivity restrictions.

ACLs provide a database-specific, user-friendly way to enforce IP-based access control.

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.

Graph query languages, like Oracle’s Property Graph Query Language (PGQL), are designed for graph databases:

Correct Answer (D): “Ability to specify patterns” is a defining feature. Graph queries excel at defining and matching patterns (e.g., nodes and edges) to explore relationships, such as finding paths or subgraphs, critical for applications like social network analysis or fraud detection.

Incorrect Options:

A: Key-value queries are typical of NoSQL key-value stores, not graph databases.

B: While scripting may be possible in some contexts, it’s not a core feature of graph query languages.

Oracle Database provides several techniques to optimize data access from Object Storage, particularly in the context of Autonomous Database, leveraging external tables and advanced storage formats. The question asks for four correct methods, and based on Oracle documentation, the following are the most applicable:

Correct Answer (A):Scan avoidance using partitioned external tables

Partitioned external tables allow Oracle Database to skip irrelevant partitions when querying data stored in Object Storage. By organizing data into partitions (e.g., by date or region), the database engine can prune partitions that don’t match the query predicates, significantly reducing the amount of data scanned and improving performance. This is a well-documented optimization for external data access in Oracle Database and Autonomous Database environments.

Correct Answer (D):Scan avoidance using columnar pruning for columnar stores like parquet and orc

Columnar pruning is a technique where only the required columns are read from columnar file formats such as Parquet or ORC stored in Object Storage. These formats store data column-wise, enabling the database to avoid scanning entire rows or irrelevant columns, which is particularly efficient for analytical queries common in Autonomous Data Warehouse (ADW). This is a standard optimization supported by Oracle’s external table framework when accessing Object Storage.

Correct Answer (E):Optimized data archive using hybrid partitioned tables

Hybrid partitioned tables combine local database partitions with external partitions stored in Object Storage. This allows older, less frequently accessed data to be archived efficiently in the cloud while remaining queryable alongside active data in the database. The database optimizes access by seamlessly integrating these partitions, reducing costs and improving archival efficiency. This feature is explicitly supported in Oracle Database and enhanced in Autonomous Database for data lifecycle management.

Correct Answer (F):Optimized data archive using partitioned external tables

Similar to hybrid partitioned tables, using partitioned external tables alone optimizes data archiving by storing historical data in Object Storage with partitioning (e.g., by year). This method enables efficient querying of archived data by pruning unneeded partitions, offering a cost-effective and scalable archival solution. It’s a distinct approach from hybrid tables, focusing solely on external storage, and is widely used in Oracle environments.

Incorrect Options:

B. Scan avoidance using columnar pruning for .csv files

CSV files are row-based, not columnar, and lack the internal structure of formats like Parquet or ORC. While Oracle can read CSVs from Object Storage via external tables, columnar pruning is not applicable because CSVs don’t support column-wise storage or metadata for pruning. This makes this option incorrect as a specific optimization technique, though basic predicate pushdown might still reduce scanning to some extent.

C. Scan avoidance using block skipping when reading parquet and orc files

Block skipping (or row group skipping) is a feature in some database systems where metadata in Parquet or ORC files allows skipping entire blocks of data based on query filters. While Oracle supports Parquet and ORC through external tables and can leverage their columnar nature (via pruning), “block skipping” is not explicitly highlighted as a primary optimization in Oracle’s documentation for Autonomous Database. It’s more commonly associated with systems like Apache Spark or Hive. Oracle’s focus is on columnar pruning and partitioning, making this option less accurate in this context.

Why Four Answers?

The question specifies “four ways,” and while six options are provided, A, D, E, and F are the most directly supported and documented methods in Oracle Autonomous Database for optimizing Object Storage access. Options B and C, while conceptually related to data access optimizations, are either inapplicable (CSV lacks columnar structure) or not explicitly emphasized (block skipping) in Oracle’s feature set for this purpose.

This selection aligns with Oracle’s focus on partitioning and columnar formats for efficient cloud data access, ensuring both performance and archival optimization.

Full Detailed In-Depth Explanation:

The DBMS_CLOUD package facilitates cloud integration:

A:True. CREATE_EXTERNAL_TABLE creates external tables for querying cloud data directly.

B:False. No DELETE_FILE procedure exists; credential management uses DROP_CREDENTIAL.

C:True. CREATE_CREDENTIAL securely stores cloud storage credentials.

D:True. VALIDATE_EXTERNAL_TABLE checks file integrity and logs errors.

E:False. PUT_OBJECT uploads files to cloud storage, not into the database.

Full Detailed In-Depth Explanation:

When provisioning an Autonomous Container Database (ACD) on dedicated infrastructure, Oracle provides specific options for backup retention periods to balance data recovery needs with storage costs. According to the official Oracle documentation, the available backup retention periods for a dedicated ACD are:

7 days: This is the default retention period for a newly provisioned ACD.

15 days: An option for extended retention beyond the default.

60 days: The maximum supported retention period for ACDs, offering the longest recovery window.

The option of120 daysis not supported as a backup retention period for an Autonomous Container Database. This limitation is due to the design of the Autonomous Database service, which caps retention at 60 days to optimize storage and performance on dedicated Exadata infrastructure. Attempting to set a retention period beyond 60 days is not an available choice during provisioning. Users must select a retention period that meets their recovery point objectives (RPO) within these constraints, noting that longer retention increases storage usage and associated costs.

Full Detailed In-Depth Explanation:

When provisioning an Autonomous Database (ADB) on dedicated infrastructure, the placement within the infrastructure is critical:

A. Listener endpoint:Incorrect. This is for connectivity, not placement.

B. Client Credentials wallet:Incorrect. This is for secure connections, not determining location.

C. The container database in which the Autonomous instance should run:Correct. On dedicated infrastructure, an Autonomous Container Database (ACD) hosts multiple ADB instances. Selecting the ACD during provisioning determines where the ADB resides, affecting resource allocation and isolation.

D. The compartment:Incorrect. Compartments organize resources in OCI, but multiple ACDs can exist within a compartment, so this doesn’t pinpoint the exact location.

Choosing the ACD is a key provisioning step for dedicated deployments.

Network Security Groups (NSGs) in OCI control network traffic to Autonomous Database instances:

Correct Answer (D): You can configure up to 5 NSGs for an Autonomous Database. This limit allows sufficient flexibility to define multiple security rules while maintaining manageability. NSGs can be assigned during provisioning or updated later via the OCI Console or API, restricting access to specific IP ranges or VCNs.

Incorrect Options:

The Data Load Explore tool in Autonomous Database helps users analyze loaded data. The correct tab is:

Statistics tab (B):The Statistics tab displays detailed metadata about a table, including its size (e.g., in MB or GB), number of rows, and number of columns. For example, afterloading a CSV into a table SALES, this tab might show “Rows: 10,000, Columns: 5, Size: 2.3 MB,” providing a quick overview of the dataset’s scale and structure. It’s designed for understanding data volume and composition, aiding decisions like partitioning or indexing.

The incorrect options are:

Hierarchies tab (A):This tab shows hierarchical relationships in the data (e.g., parent-child links), not basic table metrics like size or row count. It’s more about data organization than statistics.

Data Sources tab (C):This tab lists the sources of loaded data (e.g., OCI Object Storage buckets or files), not the resulting table’s properties. It focuses on origin, not metrics.

Measures tab (D):The Measures tab defines numerical aggregates (e.g., sum of sales), used for analytics, not raw table statistics like row or column counts.

The Statistics tab is the go-to for table sizing details in Data Load Explore.

Full Detailed In-Depth Explanation:

Since only four options are provided but the format requests two answers, I’ll assume E from a prior question context. Let’s evaluate:

A:True but conditional. Database Actions is accessible with a Private Endpoint, but requires proper network setup (e.g., VCN peering), not guaranteed by default.

B:True. Oracle APEX is accessed exclusively via the “Developer” menu in the Service Console, not other interfaces.

C:False. Oracle Machine Learning (OML) is available in both ADW and ATP, not just ADW.

D:False. Database Actions access requires specific user privileges (e.g., DWROLE), not granted to all users by default.

E (assumed):True. SQL Developer Web is exclusive to Autonomous Database, not traditional Oracle databases.

B and E are the most definitively true statements per documentation.

Securing an Autonomous Database after a user departs involves:

Correct Answer (C): “Rotate the instance wallet and share the new wallet with the remaining users” invalidates the old wallet’s credentials (e.g., certificates in ewallet.p12). Since the wallet secures client connections, rotating it ensures the departed user’s access is revoked, even if they retained a copy.

Incorrect Options:

A: Trusting the user is a security risk, not a solution.

B: Deleting the database user ID doesn’t address wallet-based access if credentials were shared externally.

Application Continuity ensures seamless failover for applications:

Correct Answer (B): EXEC DBMS_CLOUD_ADMIN.ENABLE_APP_CONT(''); is the correct command for Autonomous Database on Shared Infrastructure. It enables Application Continuity for a specific service (e.g., tpurgent), leveraging the DBMS_CLOUD_ADMIN package designed for cloud-specific administration.

Incorrect Options:

A: ALTER SESSION only affects the current session, not persistent database-wide settings.

Defining a maintenance schedule for Dedicated Exadata Infrastructure allows customization:

Correct Answer (B): “Month of the Quarter, Week of the Month, Day of the Week, Start Hour” is the correct set. For example, you can specify “Month 2 of Q1, Week 3, Wednesday, 02:00 AM,” aligning with quarterly planning while offering weekly and daily precision.

Incorrect Options:

A: “Quarter of the Year” and “Date of the Month” are less flexible than week-based options and not the standard format.

C: “Month of the Year” skips the quarterly structure used in dedicated maintenance.

When an Autonomous Database is stopped, its operational state changes significantly:

Correct Answer (C): “User with DWROLE can still access the database” isnot correct. When the database is stopped, all access is disabled, including for users with roles like DWROLE (a predefined role for Data Warehouse tasks). The database is offline, and no connections or operations are possible until it is restarted.

True Statements:

A: Tools (e.g., SQL Developer, JDBC clients) cannot connect to a stopped instance because the database services are unavailable.

B: In-flight transactions and queries are terminated upon stopping, with any uncommitted changes rolled back to maintain data consistency.

Connecting an OCI Marketplace image (e.g., a compute instance running a preconfigured application) to a shared Autonomous Database (ADB) involves network configuration. The correct statement is:

Compute Image and Shared ADB must be in the same VCN and Subnet (A):For a compute instance from the OCI Marketplace to communicate with a shared Autonomous Database, both must reside in the same Virtual Cloud Network (VCN) and subnet. This ensures direct network connectivity without requiring complex routing or public internet traversal. By default, shared ADB instances use private endpoints within a VCN, and placing the compute instance in the same subnet allows seamless access using the database’s private IP address. For example, if the ADB is in subnet 10.0.1.0/24, the compute instance must also be in that subnet to connect via Oracle Net Services (e.g., using a wallet and tnsnames.ora).

The incorrect options are:

ADB must be configured with Private endpoints (B):While shared ADB instances are configured with private endpoints by default (not publicly accessible), this is not a configurable option you “must” set—it’s inherent to shared infrastructure. Thus, it’s not a requirement you actively enforce for this scenario; it’s already true.

ADB must be configured with NSG (C):Network Security Groups (NSGs) are optionalfor controlling traffic to an ADB. You can use NSGs for finer-grained security, but they are not mandatory; Security Lists at the subnet level can suffice. Hence, this is not a universal requirement for connectivity.

Cannot connect OCI Marketplace image to shared ADB (D):This is false. OCI Marketplace images (e.g., a web server or analytics tool) can connect to a shared ADB, provided network and authentication prerequisites (like same VCN/subnet and client credentials) are met.

This requirement simplifies network setup and enhances security by keeping communication internal to the VCN. For instance, a Marketplace image like a web application could query an ADB in the same subnet using JDBC or ODBC, leveraging the private endpoint.

Autonomous Data Warehouse (ADW) uses consumer groups (High, Medium, Low) to manage resource allocation:

Correct Answer (A): “Low provides highest concurrency and lowest resources, and DoP is 1” is true. The Low group is designed for many lightweight, short-running queries, offering maximum concurrent sessions but minimal CPU/memory per session, with a Degree of Parallelism (DoP) of 1 (serial execution).

Incorrect Options:

B: High prioritizes resources, not concurrency; it has fewer sessions with more power.

C: Medium offers balanced resources and concurrency; queries can run in parallel (DoP > 1), not just serially.

Cloning from a backup in Autonomous Database has a minimum age requirement:

Correct Answer (A): The earliest timestamp allowed is2 hoursafter the backup is created. This ensures data consistency by allowing time for any in-flight transactions or writes to stabilize in the backup, preventing incomplete or corrupted clones.

Incorrect Options:

B: 24 hours is the default retention period, not the minimum cloning age.

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.

Creating an Autonomous Database (ADB) via OCI’s REST API involves a specific endpoint. The correct command is:

POST /20160918/autonomousDatabases (D):This is the official REST API endpoint to create an ADB instance. The POST request to /20160918/autonomousDatabases (versioned at API 20160918) submits a JSON payload defining the database (e.g., compartment, name, workload type). Example:

curl -X POST \

-H "Authorization: Bearer " \

-H "Content-Type: application/json" \

-d '{

"compartmentId": "ocid1.compartment.oc1..example",

"dbName": "MYADB",

"cpuCoreCount": 1,

"dataStorageSizeInTBs": 1,

"dbWorkload": "OLTP",

"adminPassword": "Secure#123"

}'

This creates an ATP instance named MYADB with 1 OCPU and 1 TB storage. The response includes an OCID (e.g., ocid1.autonomousdatabase.oc1..example), and provisioning starts asynchronously, visible in the OCI console as “PROVISIONING.” The endpoint’s plural form (autonomousDatabases) reflects the resource collection, consistent with OCI API conventions.

The incorrect options are:

POST /20160918/createADB (A):No such endpoint exists. OCI APIs use resource-based paths (e.g., /autonomousDatabases), not action-specific ones like createADB.

POST /20160918/createautonomousDatabases (B):Incorrect syntax—APIs don’t prepend “create” to resource paths, and “autonomousDatabases” is lowercase here, matching the real endpoint.

POST /20160918/createDatabases (C):Too generic; it doesn’t specify “autonomous” databases, and no such endpoint exists for ADB creation.

This REST command is a programmatic alternative to console-based provisioning, ideal for automation.

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.

Oracle Cloud Infrastructure (OCI) is designed with a hierarchical structure to ensure high availability and fault tolerance:

Correct Answer (B): “An OCI region is a localized geographic area, and an availability domain is one or more data centers located within a region” accurately describes OCI’s architecture. A region is a standalone geographic area (e.g., US East), and availability domains (ADs) are isolated data centers within that region, enhancing resilience.

Correct Answer (D): “Because availability domains do not share infrastructure such as power or cooling, or the internal availability domain network, a failure at one availability domain within a region is unlikely to impact the availability of the others within the same region” reflects OCI’s design for fault isolation. ADs are physically separate, minimizing the risk of cascading failures.

Incorrect Options:

A: Regions are independent, not dependent, and there’s no 5,000-kilometer restriction; they are globally distributed for latency and redundancy purposes.

Compartment quotas in OCI control resource usage within compartments. The incorrect statement is:

Compartment quotas are set by Oracle (A):This is false. Compartment quotas are not set by Oracle; they are defined by OCI administrators using quota policies in the Identity and Access Management (IAM) system. Admins write policies (e.g., set database quota to 2 autonomous-databases in tenancy) to limit resources like Autonomous Databases percompartment, giving customers full control over resource allocation. Oracle provides the framework, but the specific quotas are user-defined, not Oracle-imposed.

The correct statements are:

Along with compartment budgets, compartment quotas create a powerful toolset to manage your spending (B):True. Quotas limit resource creation (e.g., max 5 ADBs), while budgets track spending (e.g., $1000/month), together offering comprehensive cost management. For example, a quota might cap ADB instances, and a budget alerts when costs approach a threshold.

There are three types of quota policy statements which are set, unset, and zero (C):True. SET assigns a quota (e.g., set compute quota to 10 instances), UNSET removes it, and ZERO sets it to none, effectively blocking resource creation. These verbs provide flexible quota management.

Compartment quotas use policies that allow allocation of resources with a high level of flexibility (D):True. Policies are written in OCI’s IAM syntax, allowing granular control (e.g., set database quota to 1 autonomous-database where target.compartment.id = 'ocid1.compartment...'), tailored to specific compartments or resources.

This customer-driven approach distinguishes quotas from Oracle-managed limits.

When Autonomous Database integrates with object storage (e.g., Oracle Cloud Infrastructure Object Storage), it optimizes data access. The correct answer is:

Scan partition tables (B):Oracle leverages partition pruning when scanning tables stored in object storage. This means it only scans the relevant partitions based on query predicates, significantly reducing I/O and improving performance. This is particularly effective for partitioned tables stored in formats like Parquet or ORC, which support partitioning.

The incorrect options are:

Prune columns in parquet files (A):While column pruning is possible with columnar formats like Parquet, the primary optimization highlighted in Oracle’s documentation for object storage integration is partition pruning, not column pruning alone.

Scan hybrid partition tables (C):“Hybrid partition tables” is not a standard term in this context. Oracle supports external partitioned tables, but the focus is on scanning partitioned tables, not a hybrid-specific optimization.

Prune columns in CSV files (D):CSV files are row-based and do not natively support column pruning, making this less effective compared to partition scanning.

Partition pruning is a key optimization for external tables in object storage, enhancing query efficiency.

Autonomous Database provides predefined roles tailored to specific use cases. The correct answeris:

DWROLE (B):The DWROLE predefined role is designed for Data Warehouse developers. It includes privileges commonly needed for data warehousing tasks, such as creating tables, views, and materialized views, as well as executing analytical queries. This role is optimized for Autonomous Data Warehouse (ADW) workloads.

The incorrect options are:

ADBDEV (A):There is no predefined ADBDEV role in Autonomous Database; this appears to be a fictional or misinterpreted role.

ADMIN (C):The ADMIN role is a superuser role with full database privileges, far exceeding the needs of a typical Data Warehouse developer and not tailored to that specific use case.

ADWC (D):This is not a predefined role; it might be a typo or confusion with ADW (Autonomous Data Warehouse), but no such role exists.

DWROLE is the best fit for a Data Warehouse developer’s needs.

Critical events in Autonomous Database are those requiring immediate attention due to potential security or operational impacts:

Correct Answer (D): “Admin Password Warning” is a critical event because it indicates the admin password is nearing expiration (typically within 7 days). If not updated, it could lock out administrative access, posing a security and availability risk.

Incorrect Options:

A: “Maintenance Begin” is an operational event, not critical, as it’s planned and managed by Oracle.

B: “Database Connection” is a routine activity, not an event requiring urgent action.

C: “Schedule Maintenance Warning” is informational, not critical, as it’s a precursorto planned maintenance.

Autonomous Database on Dedicated Infrastructure offers unique features:

Correct Answer (A): “Users are offered greater control and isolation starting at the Exadata Cloud Infrastructure level” highlights dedicated hardware (compute, storage, network), ensuring isolation and performance not available in shared setups.

Correct Answer (E): “Users have more control over the maintenance schedule” allows scheduling maintenance windows, unlike shared infrastructure’s fixed schedules.

Incorrect Options:

B: OS customization is not allowed; Oracle manages the stack fully.

C: No OS access is provided; it’s a managed service.

Data Transforms is a feature in Autonomous Database for designing data transformations. The two correct statements are:

Data Transforms allows you to design data transformations in the form of data loads, data flows, and workflows (B):True. Data Transforms provides a graphical interface to create data loads (importing data), data flows (transforming data), and workflows (sequencing operations), simplifying ETL processes within ADB.

All capabilities to transform data in ODI Classic are available with ODI Web Edition (D):True. Oracle Data Integrator (ODI) Web Edition, which integrates with Data Transforms, retains the full transformation capabilities of ODI Classic, adapted for a web-based interface.

The incorrect statements are:

Data Transforms provides access to Oracle Data Integrator (ODI) Web Edition (A):False. Data Transforms is a distinct tool within ADB; while it leverages ODI under the hood, it does not directly provide access to ODI Web Edition as a standalone product.

Workflows for Data Transforms are only available on the ODI Web Edition (C):False. Workflows are part of Data Transforms itself, not exclusive to ODI Web Edition.

These features enhance data integration in ADB.

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.

Full Detailed In-Depth Explanation:

A:False. APEX is for app development, not data exploration.

B:False. SQL Developer Web is for SQL queries, not pivot tables.

C:True. Business Models in ADW automates data exploration and generates pivot tables.

D:False. Data Load is for importing data, not analysis.

Full Detailed In-Depth Explanation:

When restoring or cloning an Autonomous Database (ADB), Oracle enforces a minimum backup age to ensure data consistency and integrity. The official Oracle documentation specifies that backups used for these operations must be at least24 hours old. This requirement exists because:

Backups need time to complete and stabilize, ensuring all transactions are fully committed and the backup is consistent.

Recent backups (e.g., less than 24 hours old) may still be in progress or lack full verification, risking incomplete or corrupted restores/clones.

Options B (5 minutes), C (2 hours), and D (1 day) are either too short or redundant:

5 minutesand2 hours: Too recent, violating the 24-hour rule.

1 day: Matches 24 hours but is less precise than the explicit “24 hours” phrasing in the documentation.

For the Business Analyst’s exploration, they can access tools like SQL Developer Web or Data Load via the OCI Console under the “Tools” tab, but this question focuses on the backup age constraint, making A the best answer.

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 JSON Database supports:

A:True. SODA provides NoSQL-style access for JSON documents.

B:False. SQL is secondary; SODA/REST are primary for JSON data.

C:True. REST APIs are supported but require enablement.

D:True. The OCI console offers the JSON Online Developer tool.

E:False. No such downloadable tool exists for Autonomous JSON.

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.

Viewing the maintenance history of Autonomous Exadata Infrastructure (AEI) requires navigating the OCI console correctly. The correct path is:

Under Solutions and Platforms then Platform Services then Autonomous Exadata (C):In the OCI console, AEI is categorized under “Solutions and Platforms” (a section for integrated services), then “Platform Services” (covering cloud platform offerings), and finally “Autonomous Exadata.” Here, you select your AEI instance (e.g., by name or OCID), and the details page displays a “Maintenance History” section listing past events (e.g., patching dates, durations, and statuses like “Completed on 2025-03-01”). For example, a quarterly RU applied on January 15 might show “Patch Applied: RU 23.1” with start/end times. This path reflects AEI’s role as a dedicated platform supporting Autonomous Container Databases (ACDs) and Autonomous Databases (ADBs).

The incorrect options are:

Under Core Infrastructure then Compute then Autonomous Exadata (A):“Core Infrastructure” > “Compute” is for virtual machines or bare metal hosts, not Exadata infrastructure. AEI isn’t a compute instance; it’s a database platform.

Under Database then Autonomous Transaction Processing then Autonomous Exadata (B):“Database” > “Autonomous Transaction Processing” focuses on ATP instances, not the underlying Exadata infrastructure. AEI maintenance is separate from specific ADB types.

Under Core Infrastructure then Autonomous Exadata (D):“Core Infrastructure” doesn’t directly list AEI; it’s too broad and lacks the “Platform Services” context needed for Exadata-specific management.

This navigation ensures you access AEI-specific maintenance details efficiently.

The OCI Command Line Interface (CLI) provides a range of commands for managing Autonomous Database via OCI APIs. The correct answer is:

Create, Get, List, Stop, Restore (B):These are key operations supported by the OCI CLI for Autonomous Database:

Create:oci db autonomous-database create provisions a new ADB instance.

Get:oci db autonomous-database get retrieves details of a specific ADB.

List:oci db autonomous-database list lists all ADBs in a compartment.

Stop:oci db autonomous-database stop halts the database.

Restore:oci db autonomous-database restore restores from a backup.

The incorrect options are:

A (Start, Delete, Update, Query, Stop):“Query” is not a CLI command; “Delete” and “Update” are valid but not part of this specific subset.

C (Create, Query, Update, List, Start):“Query” is invalid; “Update” is supported but not listed here.

D (Create, Query, List, Stop, Restore):“Query” is not a valid CLI operation.

This subset reflects common management tasks via CLI.

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.

The Always Free tier of Autonomous Database has specific limits. The two correct restrictions are:

Maximum of two Always Free Databases per OCI tenancy (B):OCI’s Always Free tier allows up to two free ADB instances per tenancy (e.g., one ATP, one ADW). This limit ensures fair resource distribution across users. For example, you might create FREEATP1 (1 OCPU, 20 GB) and FREEADW1 (1 OCPU, 20 GB) in your tenancy, but a third free instance isn’t permitted—you’d need a paid upgrade. This is tracked by tenancy OCID, visible in the OCI console under “Limits.”

Maximum of one OCPU per Database (D):Each Always Free ADB is capped at 1 OCPU, non-scalable, with 20 GB of storage. This restricts compute power (e.g., no auto-scaling to 3x like paid tiers), suitable for small workloads like dev/test apps. For instance, a free ATP instance runs a lightweight app with SELECT * FROM users, but can’t handle heavy concurrency due to the single OCPU.

The incorrect options are:

Supports only ATP as a workload type (A):False. Always Free supports both ATP (transactional) and ADW (warehouse) workload types, giving flexibility for OLTP or analytics (e.g., ATP for a web app, ADW for reports).

Oracle Application Express (APEX) not included (C):False. APEX is included in both free ATP and ADW instances, pre-installed and accessible via the OCI console (e.g., “Development” > “APEX”). You can build apps like a task tracker without extra cost.

These restrictions balance free access with resource constraints, encouraging upgrades for heavier use.

Oracle Autonomous Database is designed to run on specific infrastructure optimized for its managed capabilities:

Correct Answer (B):Dedicated Exadata Infrastructureprovides a fully dedicated Exadata system for a single tenant, offering maximum isolation, performance, and customization (e.g., maintenance scheduling).

Correct Answer (D):Shared Exadata Infrastructureallows multiple Autonomous Database instances to share Exadata resources, providing a cost-effective option for smaller workloads while retaining automation benefits.

Incorrect Options:

A: Virtual Machines (VMs) on OCI are not a supported deployment platform for Autonomous Database. It requires Exadata hardware for its self-managing features, unlike traditional OCI VMs used for manual database setups.

Keeping Autonomous Database tables synchronized with an on-premises data source involves loading and updating data from external locations. TheCloud Locations cardon the Data Loadpage is the correct method:

Correct Answer (B): The Cloud Locations card allows users to connect to Oracle Cloud Infrastructure (OCI) Object Storage buckets and load data into Autonomous Database tables. By regularly updating the data in Object Storage from the on-premises source (e.g., via scripts or tools), you can maintain synchronization using this feature. It supports automated data loading workflows when paired with appropriate processes.

Incorrect Options:

A: Oracle REST Data Services (ORDS) is used for building RESTful web services, not for direct data synchronization from on-premises sources to Autonomous Database tables.

C: The Link Data option enables linking to external database tables (e.g., via database links), but it doesn’t inherently synchronize data; it provides access rather than replication.

SSH keys in OCI are used for secure access, but their role in API calls needs clarification. The correct answer is:

Navigate to Identity, select Users panel on the console and select "Add Public Key" (D):This is the correct process, but with a caveat—it’s about API authentication, not SSH for API calls per se. In OCI, API calls are authenticated using API keys (RSA key pairs), not SSH keys directly. To enable API access for a user, you generate a public/private key pair (e.g., using openssl), then add the public key in the OCI console:

Go to “Identity & Security” > “Users.”

Select the user (e.g., john.doe).

Under “API Keys,” click “Add API Key.”

Upload the public key (e.g., ~/.oci/oci_api_key_public.pem).This associates the key with the user, allowing API calls (e.g., oci db autonomous-database list) authenticated via the private key and config file (e.g., ~/.oci/config). The question’s phrasing (“SSH key”) likely misuses terminology, intending “API key,” as SSH keys are for compute instance access, not APIs. For example, a user might add a key to call the ADB API, securing requests with a signature.

The incorrect options are:

On the Autonomous Database Console (A):The ADB console manages database-specific settings (e.g., wallets), not user API keys, which are handled at the tenancy level under Identity.

SSH keys are not required in Oracle Cloud Infrastructure (B):False in general—SSH keys are needed for compute instances—but misleading here, as API calls use API keys, not SSH keys. Authentication (e.g., via tokens or keys) is required for APIs.

SSH keys cannot be added from console. They have to be added using REST APIs only (C):False. The console supports adding API keys under the Users panel; REST APIs (e.g., CreateApiKey) are an alternative, not the only method.

The correct path reflects OCI’s user management for API access, despite the SSH terminology confusion.

Migrating to Autonomous Database supports multiple methods. The three correct options are:

GoldenGate on-premise installation (A):Oracle GoldenGate (on-prem) replicates data from source databases (e.g., Oracle, MySQL) to ADB, supporting real-time or batch migration. You install GoldenGate on-prem, configure extract/replicat processes (e.g., extracting from an Oracle 19c source), and target an ADB instance using credentials and wallet. For example, it might sync an on-prem ORDERS table to ADB with near-zero latency, ideal for live migrations.

GoldenGate Cloud Service (D):GoldenGate Cloud Service, a managed OCI offering, performs the same replication but runs in the cloud. You provision it via OCI Marketplace, configure it to pull from a source (e.g., on-prem or another cloud), and push to ADB. For instance, it could replicate a SaaS database to ADB for analytics, minimizing on-prem overhead. Both GoldenGate options support initial loads and continuous sync.

Data Pump export/import (E):Data Pump exports data/schemas from a source (e.g., expdp hr/hr schemas=HR directory=DATA_PUMP_DIR) to a dump file, which you upload to OCI Object Storage. Then, import into ADB using DBMS_CLOUD.COPY_DATA (e.g., targeting a HR schema). It’s great for one-time migrations, like moving a 12c database to ADB, with flexibility to exclude objects (e.g., indexes).

The incorrect options are:

RMAN Cross-Platform backup and restore (B):RMAN restores physical backups, but ADB’s managed nature prevents direct RMAN restores—users can’t access the file system. RMAN is used for ADB backups internally by Oracle, not customer migrations.

Data Guard Physical Standby (C):Data Guard creates physical standbys for HA, not migration to ADB. ADB uses Autonomous Data Guard internally, but it’s not a migration tool from external sources.

PDB unplug/plug operation (F):Unplugging/plugging PDBs requires file-level access, unsupported in ADB due to its managed storage. You’d use Data Pump instead for PDB data.

These methods offer robust, flexible migration paths to ADB.

The client credentials wallet for connecting to an Oracle Autonomous Database contains specific files required for secure connectivity. These files are downloaded from the OCI Console when you generate a wallet:

Correct Answer (A): protocol.ora is not a standard component of the client credentials wallet. It is typically used in traditional Oracle Database setups to define protocol parameters (e.g., TCP vs. IPC), but in Autonomous Database, such details are managed by Oracle and embedded within other wallet files like ewallet.p12.

Included Files:

B. ewallet.p12: Contains the encrypted private key and certificates for authentication.

C. sqlnet.ora: Specifies network configuration details (e.g., wallet location, encryption settings).

D. keystore.jks: A Java KeyStore file for Java-based applications to authenticate with the database.

Full Detailed In-Depth Explanation:

The Service Console in Autonomous Database is for database-level management:

A:False. Auto-scaling is managed via OCI console.

B:True. It allows monitoring and terminating runaway SQL statements.

C:False. Compartment moves are OCI console tasks.

D:False. Manual backups are initiated via OCI or SQL*Plus.