Free 1Z0-184-25 Practice Test Questions and Answers (2026)

To fetch the top five nearest vectors for a specific category, combine relational filtering (e.g., WHERE

category = 'X') with similarity search (C) (e.g., VECTOR_DISTANCE with ORDER BY and FETCH FIRST 5

ROWS). UNION ALL (A) is for combining result sets, not filtering. Omitting WHERE (B) ignores the

category constraint. VECTOR_INDEX_HINT (D) influences index usage, not filtering, and skipping

WHERE misses the requirement. Oracle’s vector search examples use WHERE clauses with similarity

functions for such tasks.

Reference:Oracle Database 23ai AI Vector Search Guide, Section on Querying Vectors.

Select AI in Oracle Database 23ai enables natural language queries by integrating with OCI

Generative AI services. The first step in setting up the practice environment is to optionally create an

OCI compartment (A), which organizes and isolates resources in Oracle Cloud Infrastructure (OCI).

This is foundational because subsequent steps—like defining policies or configuring the Autonomous

Database—depend on a compartment structure, though an existing compartment can be reused,

making it optional. Creating a policy (B) is a subsequent step to grant access to OCIGenerative AI,

requiring a compartment first. Dropping compartments (C) is irrelevant and disruptive. Creating a

user account (D) is not specified as the initial step in Select AI setup. Oracle’s Select AI

documentation lists compartment setup as the starting point in OCI configuration.

Reference:Oracle Database 23ai New Features Guide, Section on Select AI Setup.

Oracle Data Pump in 23ai natively supports the VECTOR data type (C), allowing export and import of

tables with vector columns without conversion or plug-ins. This facilitates vector search application

migrations, preserving dimensional and format integrity (e.g., FLOAT32). BLOB storage (A) isn’t

required; VECTOR is a distinct type. Data Pump doesn’t treat vectors as text (B), avoiding corruption;

it handles them as structured arrays. No specialized plug-in (D) is needed; native support is built-in.

Oracle’s Data Pump documentation confirms seamless handling of VECTOR data.

Reference:Oracle Database 23ai Utilities Guide, Section on Data Pump and VECTOR.

RAG in Oracle Database 23ai combines vector search with LLMs to enhance responses by retrieving

relevant private data from the database (e.g., via VECTOR columns) and augmenting LLM prompts.

This (A) improves context-awareness and precision, leveraging enterprise-specific data without

retraining LLMs. Optimizing LLM performance (B) is a secondary benefit, not the core focus. Training

specialized LLMs (C) is not RAG’s purpose; it uses existing models. Real-time streaming (D) is possible

but not the primary benefit, as RAG focuses on stored data retrieval. Oracle’s RAG documentation

emphasizes private data integration for better LLM outputs.

Reference:Oracle Database 23ai AI Vector Search Guide, Chapter on RAG.

In Oracle Database 23ai, DBMS_VECTOR_CHAIN.UTL_TO_TEXT is the PL/SQL function that converts

documents in formats like PDF, DOC, JSON, XML, or HTML into plain text, a key step in preparing data

for vectorization in RAG workflows. DBMS_VECTOR.TEXT_TO_PLAIN (A) is not a valid function.

DBMS_VECTOR_CHAIN.UTL_TO_CHUNKS (C) splits text into smaller segments, not converts

documents. DBMS_VECTOR.CONVERT_TO_TEXT (D) does not exist in the documented packages.

UTL_TO_TEXT is part of the DBMS_VECTOR_CHAIN package, designed for vector processing

pipelines, and is explicitly noted for document conversion in Oracle’s documentation.

Reference:Oracle Database 23ai PL/SQL Packages and Types Reference, DBMS_VECTOR_CHAIN.

SQLLoader in Oracle 23ai supports loading VECTOR data from CSV files, requiring vectors to be

formatted as text. A critical consideration is enclosing components in curly braces (A), e.g., {1.2, 3.4,

5.6}, to match the VECTOR type’s expected syntax (parsed into FLOAT32, etc.). FVEC (B) is a binary

format, not compatible with CSV text input; SQLLoader expects readable text, not fixed offsets.

Sparse format (C) isn’t supported for VECTOR columns, which require dense arrays. SQLLoader

doesn’t normalize vectors automatically (D); formatting must be explicit. Oracle’s documentation

specifies curly braces for CSV-loaded vectors.

Reference:Oracle Database 23ai Utilities Guide, Section on SQLLoader for Vectors.

Approximate similarity search (ANN) in Oracle 23ai (B) uses indexes (e.g., HNSW, IVF) to trade

accuracy for speed, returning near-matches faster by not comparing all vectors. Exact search

compares every vector (A), not ANN. It doesn’t guarantee 100% accuracy (C); that’s exact search. It’s

faster, not slower (D), than exact search due to indexing. Oracle’s documentation defines ANN’s

speed-accuracy trade-off as its hallmark.

Reference:Oracle Database 23ai AI Vector Search Guide, Section on Approximate vs. ExactSearch.

In Oracle Database 23ai’s Select AI, security between the Autonomous Database and OCI Generative

AI is managed using Resource Principals (B). This mechanism allows the database instance to

authenticate itself to OCI services without hardcoding credentials, enhancing security by avoiding

exposure of sensitive keys. TLS/SSL encryption (A) is used for data-in-transit security, but it’s a

complementary layer, not the primary management method. A VPN tunnel (C) is unnecessary within

OCI’s secure infrastructure and not specified for Select AI. Manual API key entry (D) is impractical and

insecure for automated database interactions. Oracle’s documentation on Select AI highlights

Resource Principals as the secure, scalable authentication method.

Reference:Oracle Database 23ai New Features Guide, Section on Select AI Security.

In Oracle Database 23ai, vector distance calculations are primarily handled by the VECTOR_DISTANCE

function, which supports multiple metrics (e.g., COSINE, EUCLIDEAN) specified as parameters (e.g.,

VECTOR_DISTANCE(v1, v2, EUCLIDEAN)). However, the question implies distinct functions, a

common convention in some databases or libraries, and Oracle’s documentation aligns L2_DISTANCE

(B) with the Euclidean metric. L2 (Euclidean) distance is the straight-line distance between two points

in vector space, computed as √∑(xi - yi)², where xi and yi are vector components. For example, for

vectors [1, 2] and [4, 6], L2 distance is √((1-4)² + (2-6)²) = √(9 + 16) = 5.

Option A, L1_DISTANCE, represents Manhattan distance (∑|xi - yi|), summing absolute differences—

not Euclidean. Option C, HAMMING_DISTANCE, counts differing bits, suited for binary vectors (e.g.,

INT8), not continuous Euclidean spaces typically used with FLOAT32 embeddings. Option D,

COSINE_DISTANCE (1 - cosine similarity), measures angular separation, distinct from Euclidean’s

magnitude-inclusive approach. While VECTOR_DISTANCE is the general function in 23ai,

L2_DISTANCE may be an alias or a contextual shorthand in some Oracle AI examples, reflecting

Euclidean’s prominence in geometric similarity tasks. Misinterpreting this could lead to choosing

COSINE for spatial tasks where magnitude matters, skewing results. Oracle’s vector search

framework supports Euclidean via VECTOR_DISTANCE, but B aligns with the question’s phrasing.

Reference:Oracle Database 23ai SQL Language Reference, Section on VECTOR_DISTANCE; AI Vector

Search Guide, Distance Metrics.

In Oracle 23ai, the DBMS_VECTOR_CHAIN package provides utilities for vector workflows.

UTL_TO_EMBEDDINGS (C) generates vector embeddings from text within the database, typically

using an ONNX model, supporting RAG and search applications. UTL_TO_CHUNKS (A) splits text, not

generates embeddings. UTL_TO_TEXT (B) converts documents to text, a preprocessing step.

UTL_TO_GENERATE_TEXT (D) doesn’t exist; text generation is handled by LLMs, not this package.

Oracle’s documentation identifies UTL_TO_EMBEDDINGS as the embedding creation function in

PL/SQL workflows.

Reference:Oracle Database 23ai PL/SQL Packages and Types Reference, DBMS_VECTOR_CHAIN.

Oracle Database 23ai introduces DBMS_AI as the primary PL/SQL package for interacting with

Generative AI services, such as OCI Generative AI, enabling features like natural language query

processing (e.g., Select AI) and AI-driven insights. DBMS_ML (B) focuses on machine learning model

training and management, not generative AI. DBMS_VECTOR_CHAIN (C) supports vector processing

workflows (e.g., document chunking, embedding), but it’s not the main interface for generative AI

services. DBMS_GENAI (D) is not a recognized package in 23ai documentation. DBMS_AI’s role is

highlighted in Oracle’s AI integration features for 23ai.

Reference:Oracle Database 23ai New Features Guide, Chapter on AI Integration.

Exadata in Oracle Database 23ai enhances AI and vector search capabilities. Vector Replication with

GoldenGate (B) supports real-time vector data distribution. SQL*Loader (C) loads vector data into

VECTOR columns. AI Smart Scan (D) accelerates AI workloads using Exadata’s storage optimizations.

However, “Native Support for Vector Search Only within the Database Server” (A) is not a feature;

vector search is natively supported across Exadata’s architecture, leveraging both database and

storage layers (e.g., via Smart Scan), not restricted to the server alone. This option misrepresents

Exadata’s distributed capabilities, making it the correct “NOT” answer.

Reference:Oracle Database 23ai Exadata System Software Guide, Chapter on AI Features.

Building a RAG application in Oracle 23ai using PL/SQL follows a logical sequence: (1) Load Document

(e.g., via SQL*Loader) into the database; (2) Split Text into Chunks (e.g.,

DBMS_VECTOR_CHAIN.UTL_TO_CHUNKS) to manage token limits; (3) Load ONNX Model (e.g., via

DBMS_VECTOR) for embedding generation; (4) Create Embeddings (e.g., UTL_TO_EMBEDDINGS) for

the chunks; (5) Vectorize Question (using the same model) when a query is received; (6) Perform

Vector Search (e.g., VECTOR_DISTANCE) to find relevant chunks; (7) Generate Output (e.g., via

DBMS_AI with an LLM). Option B matches this flow. A starts with the model prematurely. C prioritizes

the question incorrectly. D is close but loads the model too early. Oracle’s RAG workflow

documentation outlines this document-first approach.

Reference:Oracle Database 23ai AI Vector Search Guide, Chapter on RAG Workflow.

In Oracle Database 23ai, vector indexes (e.g., HNSW, IVF) are built with a specific distance metric

(e.g., cosine, Euclidean) that defines how similarity is computed. If a query specifies a different

metric (e.g., querying with Euclidean on a cosine-based index), the index cannot be used effectively,

and the query fails (A) with an error, as the mismatch invalidates the index’s structure. An exact

match search (B) doesn’t occur automatically; Oracle requires explicit control. The index doesn’t

update itself (C), and warnings (D) are not the default behavior—errors are raised instead. Oracle’s

documentation mandates metric consistency for index usage.

Reference:Oracle Database 23ai AI Vector Search Guide, Section on Vector Index Metrics.

Oracle 23ai supports two main vector indexes: IVF and HNSW. HNSW (D) is renowned for its speed

and accuracy, using a hierarchical graph to connect vectors, enabling fast ANN searches with high

recall—ideal for latency-sensitive applications like real-time RAG. IVF (C) partitions vectors for

scalability but often requires tuning (e.g., NEIGHBOR_PARTITIONS) to match HNSW’s accuracy,

trading off recall for memory efficiency. BT (A) isn’t a 23ai vector index; it’s a generic term unrelated

here. IFS (B) seems a typo for IVF; no such index exists. HNSW’s graph structure outperforms IVF in

small-to-medium datasets or where precision matters, as Oracle’s documentation and benchmarks

highlight, making it a go-to for balanced performance.

Reference:Oracle Database 23ai AI Vector Search Guide, Section on HNSW Indexing.