Q: What is New Features of 26ai in ExaCC
1. New Features of 26ai in ExaCC
- Exadata AI Smart Scan (Vector Offloading): Traditional Smart Scan offloads SQL filters. In 26ai, AI Vector Search distance calculations and index generation are completely offloaded to the Exadata storage cells. This avoids bottlenecking the compute nodes.
- Exascale VM Storage Integration: Allows running 26ai inside flexible, highly elastic Exascale storage architectures on ExaCC, separating VM-managed backups and OS images with cloud-like micro-tiering.
- Model Context Protocol (MCP) & Agentic AI: Built-in engine support allows external Large Language Models (LLMs) to use iterative reasoning to access live database schemas via specialized metadata annotations.
- True Cache: An in-memory, consistent, autonomous remote cache that speeds up application read times to sub-milliseconds without requiring manual code rewrites.
- Native SQL Firewall: Embedded security directly within the database kernel that intercepts and blocks unauthorized SQL injection attempts or unrecognized execution paths.
Oracle AI Database 26ai New Features in ExaCC
Oracle Database 26ai (the Long-Term Support release succeeding 23ai) is an AI-native database that integrates artificial intelligence directly into the data tier. When running on Exadata Cloud@Customer (ExaCC), these features leverage specialized hardware capabilities like RoCE networking, Persistent Memory (PMEM), and cell offloading:
- Exadata AI Smart Scan: Offloads heavy AI vector calculations and similarity searches directly to the Exadata storage cells. Instead of pulling massive vector data sets into the compute nodes, the storage tier filters data first, maximizing throughput.
- In-Database AI Vector Search & Native RAG: Supports native
VECTORdata types, vector indexes (HNSW and IVF), and distance functions. Generates Retrieval-Augmented Generation (RAG) prompts directly inside the database via SQL. - PDB-Level Data Guard: Allows individual Pluggable Databases (PDBs) to failover to a disaster recovery site independently, drastically reducing the blast radius compared to container-level (CDB) failovers.
- True Cache: An in-memory, consistent, and high-performance middle-tier cache that reduces ExaCC compute loads by offloading read-intensive query paths.
- In-Database SQL Firewall: Provides zero-trust security directly inside the database kernel to prevent SQL injection attacks and flag unauthorized connection paths.
Core Performance Features in Oracle AI Database 26ai on ExaCC
Oracle’s release of the AI Database 26ai running on Exadata Cloud@Customer (ExaCC) introduces specific performance innovations tailored to handle massive semantic vector processing alongside enterprise OLTP/analytic workloads:
- AI Smart Scan (Vector Offloading): Extends traditional Exadata Smart Scan to the cell storage layer. It offloads complex multi-dimensional AI Vector Search operations and distance calculations directly to the Exadata storage servers, accelerating vector execution speeds by up to 30x while protecting database compute nodes from CPU starvation.
- True Cache: An integrated, application-transparent, read-only caching layer that sits in front of the primary database. Acting like a database-aware Redis layer, it yields sub-millisecond read response times with zero application code changes.
- Exadata Exascale Software Integration: Brings a highly elastic, redirect-on-write storage model. It maximizes throughput, provides space-efficient thin clones, and supports independent resource scaling for intense data-lake or AI workloads.
- Enhanced Fast Ingest: Upgraded specifically to support rapid data loading for partitioned, compressed, and in-memory architectures—crucial for streaming real-time IoT and vector generation updates.
Interview Questions & Answers
Q1: What is AI Smart Scan in Exadata System Software 26ai, and how does it optimize database CPU cycles?
- Answer: AI Smart Scan offloads the math-heavy distance metric calculations (Cosine, Dot Product, Euclidean) used in AI Vector Search directly to the Exadata storage cells. Instead of pulling large volumes of un-indexed vector columns over the RoCE network fabric to the database compute nodes, the storage servers filter and return only the exact matches. This frees up the DB server's CPU to process critical OLTP transactions rather than exhausting its cores on multi-dimensional array math.
Q2: How does True Cache differ from setting up an external cache like Redis, and how does it guarantee transactional consistency?
- Answer: External caches require custom application code to handle cache invalidation, hydration, and read-through patterns. True Cache is fully database-aware, application-transparent, and managed natively. It maintains complete transactional consistency by streaming log changes directly from the primary database. It supports full Oracle SQL, JSON, and Vector querying without needing any modifications to application logic.
Q3: Oracle 26ai mandates the complete removal of traditional auditing. What performance or operational impacts does this bring during a migration?
- Answer: Traditional auditing is completely removed in 26ai; Unified Auditing is now the only supported mechanism. From a performance standpoint, Unified Auditing writes cleanly to a single, high-throughput internal table (
AUDSYS), reducing context switching and I/O serialization over standardSYS.AUD$writes. Operationally, you must migrate all legacy audit trails to unified audit policies prior to upgrading, or your security pipelines will instantly break.
Key Operational Challenges
- Vector Memory Allocation Overhead: Running large-scale vector indexes requires dedicated SGA/PGA sizing. Misconfiguring memory limits can cause heavy paging or force vector searches to bypass Exadata storage caching, causing massive performance drops.
- Network Sizing for Cloud Control Plane: Since ExaCC uses a split-plane topology where the public cloud OCI control plane handles administrative monitoring and the physical databases stay on-premises, sudden spikes in telemetry streaming (e.g., streaming intense AWR/ASH logs from AI workloads) can saturate management VLANs if not properly segregated.
- SQL Firewall Learning Curves: Enabling the new in-database SQL Firewall requires a "training phase" to log allowed SQL vectors. If an application deployment alters its execution path unexpectedly post-migration, the firewall may block queries, simulating a performance outage.
Migration Pre-considerations
- Mandatory Unified Auditing Migration: Profile and rewrite all standard auditing policies into Unified Auditing policies.
- Exadata Storage Grid Upgrades: Ensure your underlying storage infrastructure is updated to at least Exadata System Software 26ai (26.1+) to unlock cell offloading for vectors.
- Application Framework Driver Check: While True Cache requires zero application code adjustments, ensure that application drivers (JDBC/UCP) are updated to understand connection string routing rules for read-only caching endpoints.
Project Blueprint & Example Case Study
Project Scope: Real-Time Fraud & Customer Recommendation Engine
- Objective: Transition a legacy financial system to Oracle 26ai on ExaCC to enable real-time semantic similarity searches across transaction records while maintaining sub-second response times.
+----------------------------------------------+
| Client Application Layer |
+----------------------------------------------+
/ \
(Read-Heavy Queries) (Write/Transactional Engine)
/ \
v v
+------------------------+ +----------------------------+
| True Cache Instance | | ExaCC Primary DB Server |
| (Sub-ms Read Layer) | | (OLTP / Ingestion Engine)|
+------------------------+ +----------------------------+
|
(RoCE Network Fabric)
|
v
+----------------------------+
| Exadata Storage Cells |
| (AI Smart Scan / Offload) |
+----------------------------+
Step-by-Step Implementation Example
Step 1: Create a Vector Table for Fraud Patterns
sql
CREATE TABLE transaction_vectors (
transaction_id NUMBER PRIMARY KEY,
customer_id NUMBER,
amount NUMBER,
behavior_vector VECTOR(512, FLOAT32) -- Holds the behavioral embedding
);
Use code with caution.
Step 2: Leverage AI Smart Scan Offloading
When running a query to find suspicious matches, ExaCC naturally offloads the heavy mathematical processing down to the storage layer via AI Smart Scan:
sql
-- This distance calculation will be processed natively by Exadata Cell Storage
SELECT transaction_id, VECTOR_DISTANCE(behavior_vector, :new_incident_vector, COSINE) as distance
FROM transaction_vectors
WHERE customer_id = :cust_id
ORDER BY distance ASC
FETCH FIRST 5 ROWS ONLY;
Use code with caution.
Step 3: Configure True Cache for Real-Time Dashboards
To prevent these high-frequency lookup queries from choking the primary database nodes, the DBA spawns an application-transparent True Cache node. The application connects using a split service connection string:
- Primary Service:
prod_db_://example.com(Handles transactions and inserts). - True Cache Service:
prod_db_://example.com(Automatically routes regular queries and similarity queries to the sub-millisecond in-memory cache layer).
Q1: How does Exadata AI Smart Scan optimize AI Vector Search compared to a generic cloud database?
Answer: In generic setups, executing a vector similarity query requires loading thousands of multi-dimensional vectors from storage into compute memory, choking the network. With Exadata AI Smart Scan, the mathematical vector distance scoring is pushed down into the Exadata storage cells. The storage cells filter the closest matches and return only the relevant rows to the database node, leveraging Exadata's internal ultra-fast pipeline.
Q2: What is the architectural benefit of PDB-level Data Guard in an ExaCC 26ai consolidation environment?
Answer: Historically, Data Guard controlled replication at the CDB level. If one application required a failover, all PDBs inside that CDB had to fail over together. PDB-level Data Guard permits independent switchover/failover orchestration for a single tenant PDB. This prevents cross-tenant downtime and simplifies multi-tenant maintenance on ExaCC.
Q3: How do you address performance issues where Vector Index creation or maintenance stalls OLTP workloads on ExaCC?
Answer: High-dimensional vector indexing (like HNSW) is highly CPU and memory-intensive. To protect OLTP throughput on ExaCC, you must configure Instance Caging to restrict AI workload CPU usage, allocate dedicated memory to the vector pool (
VECTOR_MEMORY_SIZE), and offload heavy vector builds to a standby database or run them during maintenance windows using parallel execution. Project Migration Challenges & Solutions
| Challenge | Impact on Project | Mitigating Solution |
|---|---|---|
| Vector Pool Sizing & SGA Pressures | Allocating insufficient memory to the new VECTOR_MEMORY_SIZE pool causes vector operations to spill to disk, destroying performance. | Perform a thorough baseline sizing. Adjust SGA_TARGET and slice out memory specifically for the vector pool before initializing AI workloads. |
| Network Bottlenecks with External LLMs | Using DBMS_NETWORK_ACL_ADMIN to call public LLMs (e.g., OpenAI, OCI GenAI) from ExaCC introduces high latency. | Keep data processing localized. Use the Model Context Protocol (MCP) or deploy local open-source models (ONNX format) directly inside the database. |
| SQL Firewall False Positives | Strict SQL Firewall configurations can block legitimate dynamic SQL queries generated by newly deployed application microservices. | Put the SQL Firewall in Capture/Training Mode for a multi-week business cycle to log all legitimate traffic patterns before enforcing block rules. |
Pre-considerations Before Upgrading to 26ai on ExaCC
- Release Update Path: Upgrading to 26ai is streamlined. Ensure your source databases are running stable 19c or 23ai versions, then apply the correct Release Update sequence via Fleet Patching and Provisioning (FPP).
- Infrastructure Readiness: Verify your ExaCC Grid Infrastructure and Exadata Storage Server software versions support 26ai features (ESS 24.x or higher) to enable Smart Scan for vectors.
- Application Decoupling: Identify if existing applications use deprecated features (like traditional multimedia or advanced replication components) that need to be refactored into JSON-Relational Duality or Raft replication.
Project Details with Example: Enterprise RAG Service
Project Objective
Build an automated Customer Support AI Agent for a banking client that queries private internal loan guidelines (unstructured PDFs) and cross-references them against real-time customer account balances (structured tables) inside a consolidated ExaCC environment.
Technical Implementation Example
- Table Configuration: Create a single converged table storing both transactional attributes and high-dimensional document vectors.
sql
CREATE TABLE bank_loan_policies (
policy_id NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
loan_type VARCHAR2(50),
policy_text CLOB,
policy_vector VECTOR(1024, FLOAT32) -- 1024-dimensional AI Vector
);
Use code with caution.
- AI Vector Indexing: Build an index optimized for Exadata AI Smart Scan.
sql
CREATE INDEX idx_policy_vectors
ON bank_loan_policies(policy_vector)
ORGANIZATION INVERTED LIST; -- Optimized for Exadata storage offloading
- Hybrid Smart Scan Query: Execute a unified SQL query that blends relational filtering (checking active credit scores) with a vector similarity search, completely processed within the Exadata storage cells.
sql
SELECT policy_text,
VECTOR_DISTANCE(policy_vector, :input_customer_query_vector, COSINE) AS similarity_score
FROM bank_loan_policies
WHERE loan_type = 'MORTGAGE'
ORDER BY similarity_score
FETCH FIRST 3 ROWS ONLY;Q1: How does Exadata AI Smart Scan optimize AI Vector Search compared to a generic cloud database?
Answer: In a standard database, performing a semantic similarity search across millions of vector embeddings requires loading those vectors into compute memory, causing massive I/O overhead. With Exadata System Software 26ai, the database server offloads the vector distance functions (like Cosine or Euclidean distance) straight to the intelligent storage cells. Only the final, top-matched rows are returned over the RoCE network to the compute nodes, protecting database CPU capacity.
Q2: What is the upgrade path from 23ai to 26ai on an ExaCC environment? Is a full migration needed?
Answer: No complex migration or application re-certification is required. Oracle designed 26ai as a direct evolution. Moving from 23ai to 26ai is achieved by seamlessly applying the October 2025 Release Update (23.26.0) via the OCI console or dbaascli on ExaCC, which immediately unlocks the 26ai feature stack.
Q3: How do True Cache and JSON-Relational Duality views interact to benefit ExaCC workloads?
Answer: JSON-Relational Duality lets developers fetch data as JSON documents while DBAs preserve the underlying tables as structured, normalized relational data. By placing True Cache in front of this layer, high-frequency JSON lookups are cached automatically in-memory at sub-millisecond response rates, preventing the primary Exadata OLTP instances from facing execution spikes.
3. Production Challenges
- Vector Memory Overhead (SGA Tuning): AI Vector Searches rely heavily on in-memory vector indexes (like HNSW). Improperly sized
VECTOR_MEMORY_AREAparameters within the SGA will lead to performance degradation or fallback to disk-based reads. - Network Latency to External LLMs: While the data processing happens inside ExaCC at customer data centers, calling public or cloud-based LLM APIs (like OCI GenAI or OpenAI) for Retrieval-Augmented Generation (RAG) can introduce severe WAN latency issues.
- Co-managed Infrastructure Patching Coordination: Because ExaCC is a hybrid model, keeping Grid Infrastructure, Exadata Storage Software (ESS 26ai), and the Guest OS synchronized requires strict maintenance windows between the on-prem team and Oracle Cloud operations.
4. Technical Pre-considerations Before Deployment
- Network Firewall Rules for AI Endpoints: ExaCC compute nodes require secure egress access to call external AI foundational models or internal Private AI Services Containers.
- Sizing Backup Infrastructure: With 26ai handling massive unstructured files (audio/video/PDFs converted to vectors), full backups will grow drastically. Plan to leverage ExaCC’s newly supported 100Gbps backup networks.
- Character Set Compatibility: Ensure your container databases (CDB) and pluggable databases (PDB) use
AL32UTF8to correctly support broad multi-language AI vector text processing.
5. Project Details with Practical Example
Project Scenario: Semantic Enterprise Search for a Banking System
The organization wants to build an AI-powered compliance search tool. It must allow legal teams to search millions of PDF loan contracts via natural language ("Show me all high-risk clauses modified during the financial crisis") and mix that search with structured customer profile data.
Architectural Breakdown & Example Workflow
- Data Storage: Structured customer data is stored in relational tables. The PDF contracts are processed, and their text blocks are converted into 512-dimension vector embeddings.
- Table Schema with Vector Support:sql
CREATE TABLE loan_contracts ( contract_id NUMBER PRIMARY KEY, customer_id NUMBER, risk_rating VARCHAR2(10), contract_text CLOB, text_vector VECTOR(512, FLOAT32) -- Native 26ai vector data type ); - Execution (The Exadata Advantage): When a user searches the system, the query executes a hybrid SQL join. The
VECTOR_CHUNKSand similarity scores are calculated via AI Smart Scan inside the storage layer:sqlSELECT contract_id, risk_rating, VECTOR_DISTANCE(text_vector, :search_query_vector, COSINE) as similarity FROM loan_contracts WHERE risk_rating = 'HIGH' ORDER BY similarity ASC FETCH FIRST 5 ROWS ONLY;
Q1: What is Oracle GDS, and how does it differ from traditional Oracle RAC services?
Answer: Traditional Oracle Database Services (configured via
SRVCTL) only manage workloads within a single cluster or database instance. GDS extends this concept globally across multiple isolated, replicated databases. It uses Global Service Managers (GSM) to orchestrate dynamic connection load balancing, inter-database service failover, and replication lag-based routing across diverse topologies (Data Guard reader farms or GoldenGate multi-masters).Q2: Explain the architecture and core components of a GDS framework.
Answer: A GDS framework consists of four primary pieces:
- Global Service Manager (GSM): A specialized listener that monitors database metrics (load, lag, status) and routes client traffic.
- GDS Catalog: A metadata repository hosted inside an Oracle Database that tracks configuration status.
- GDS Pool: A logical grouping of replicated databases that deliver identical application services.
- Global Services: Application services defined at the pool level instead of individual databases.
Q3: What is "Lag-Based Routing" in GDS, and why is it crucial for Active Data Guard / GoldenGate setups?
Answer: When apps connect to a read-only global service, GDS allows administrators to specify a maximum allowable replication lag (e.g.,
FAILOVER_LAG_TIME=30). If a standby database falls behind the primary by more than 30 seconds, GSM automatically stops routing connections to that replica, protecting the application from stale data.Q4: How does Oracle 26ai enhance GDS capabilities compared to older versions?
Answer: Oracle 26ai brings native integrations for True Cache (mid-tier read-only caching) into GDS pools, allowing connection routing based on cache efficiency. It also optimizes AI Vector Search workload placement, routing resource-heavy semantic vector queries to specific analytical read-replicas without data engineering overhead.
2. Implementation Challenges
- Network Latency & Split-Brain Risk: Because GSM instances communicate across wide-area networks (WANs), network partitions can trigger false failovers. Mitigating this requires configuring robust "Buddy Regions".
- Application Connection Pool Coordination: To achieve runtime load balancing, clients must use compatible connection managers like Oracle Universal Connection Pool (UCP). Standard third-party pools can only leverage connect-time load balancing.
- GoldenGate Conflict Resolutions: When using GDS over multi-master GoldenGate setups, an application could write to two different databases simultaneously if misconfigured, creating data divergence challenges.
3. Pre-considerations Before Deploying GDS
- Isolated GSM Architecture: GSM software must be installed in its own unique
ORACLE_HOMEpath using dedicated binaries. Never share the base DB home. - HA for the Control Layer: Always provision at least two GSM instances per region to eliminate single points of failure within the routing layer.
- Database Licensing & Compatibility: Ensure that target databases have matching service characteristics. Mixing vastly different shapes or versions within a single GDS pool can skew performance metrics.
4. Project Details & Real-World Example
Project Scenario: Global E-Commerce AI-Native Platform
- The Goal: Build an active-active, highly resilient global e-commerce engine where clients access low-latency catalog search (utilizing Oracle 26ai Vector Search) and seamless order checkouts.
- Topology:
- Region A (US East): Primary Database (
DB_EAST) processing OLTP Read/Write data + 1 local True Cache node. - Region B (US West): Active Data Guard Standby (
DB_WEST) open for read-only vector search workloads.
- Region A (US East): Primary Database (
[ Client Application / UCP ]
│
(Queries Global Service Name)
│
┌───────────────▼───────────────┐
│ Global Service Manager (GSM) │
└───────┬───────────────┬───────┘
│ │
(R/W Traffic) │ │ (Read / Vector Search)
▼ ▼
[ DB_EAST (Pri) ] [ DB_WEST (Stby) ]
Step-by-Step Configuration Example (via GDSCTL):
1. Create the Global Catalog and Add Regions:
sql
GDSCTL> create catalog -database db_://example.com -user gds_admin/password;
GDSCTL> add region -region region_east;
GDSCTL> add region -region region_west;
2. Add the GSM Listeners:
sql
GDSCTL> add gsm -gsm gsm_east -region region_east -listener 1523;
GDSCTL> add gsm -gsm gsm_west -region region_west -listener 1523;
GDSCTL> start gsm -gsm gsm_east;
3. Define the Database Pool and Assign Members:
sql
GDSCTL> add pool -pool ecom_pool;
GDSCTL> add database -pool ecom_pool -connect_identifier DB_EAST -role PRIMARY;
GDSCTL> add database -pool ecom_pool -connect_identifier DB_WEST -role PHYSICAL_STANDBY;
4. Deploy Read/Write vs. Read-Only Global Services:
sql
-- Read/Write Service restricted to the Primary site
GDSCTL> add service -service order_txn_svc -pool ecom_pool -role PRIMARY -preferred DB_EAST;
-- Read-Only AI Search Service leveraging load balancing and maximum 10s lag
GDSCTL> add service -service ai_search_svc -pool ecom_pool -role PHYSICAL_STANDBY -failover_lag_time 10;
GDSCTL> start service -service order_txn_svc -pool ecom_pool;
GDSCTL> start service -service ai_search_svc -pool ecom_pool;
5. Client TNS Configuration:
The client connection string targets the GSM addresses rather than the underlying databases directly:
txt
ECOM_SEARCH =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = ://example.com)(PORT = 1523))
(ADDRESS = (PROTOCOL = TCP)(HOST = ://example.com)(PORT = 1523))
)
(CONNECT_DATA =
(SERVICE_NAME = ai_search_svc.ecom_pool.oradbcloud)
)
)
Q1: What is the difference between Oracle RAC and Oracle Globally Distributed Database?
A: Oracle RAC is a shared-everything architecture where multiple database instances share the same storage layer, aiming for localized high availability. Globally Distributed Database is a shared-nothing architecture where each shard has its own independent CPU, memory, and storage. It scales linearly across geographic regions and ensures total fault isolation.Q2: How does the new Raft Replication mechanism in 26ai improve over traditional Active Data Guard for sharding?
A: Prior to 23ai/26ai, each shard needed a dedicated Oracle Data Guard physical standby database for high availability. In 26ai, Raft Replication is native and consensus-driven. Data is split into smaller replication units distributed dynamically across physical shards. If a node goes down, the remaining nodes elect a new leader dynamically, reducing failover time to sub-3 seconds with zero data loss.Q3: What happens when a query does not supply a Sharding Key?
A: If a query contains a sharding key, GDS routes it as a Single-Shard Query directly to the node, maximizing performance. If no key is provided, the query becomes a Multi-Shard Query. The Shard Catalog Coordinator processes it by running parallel cross-shard queries across all nodes, aggregating the results, and passing them back to the user. This increases resource consumption and cross-network overhead.
New Features in Exadata Cloud@Customer (ExaCC) for 26aiOn Exadata Cloud@Customer (ExaCC) running Exadata System Software 24ai, 26ai unlocks game-changing hybrid and infrastructure capabilities:- Exadata AI Smart Scan: Offloads expensive AI Vector Search calculations and multi-model matrix math directly down to the Exadata cell storage servers, slashing database server I/O overhead.
- Raft-Based Replication: Empowers globally distributed databases to manage high-speed consensus and failover mechanisms natively with much faster sub-second transitions.
- True Cache Integration: Mid-tier, automatically managed read-only cache layers that run inside Exadata memory to achieve sub-millisecond query response times for vector, JSON, and relational lookups.
- Granular PDB Maintenance on ExaCC: Enables individual Per-PDB Capture for GoldenGate and standalone Data Guard PDB failovers, reducing the "blast radius" instead of forcing container-level actions.
- Monthly Infrastructure Maintenance Preferences: Greater on-premises control allowing administrators to granularly schedule, pause, or abort infrastructure patching routines on designated ExaCC components.
Pre-Considerations Before Deployment- Network Topology & Latency: GDS relies on fast network routing. Inter-region latencies must be mapped carefully so that the GDS catalog can accurately monitor replication lag.
- SGA Vector & True Cache Allocation: Ensure the System Global Area (SGA) has an explicit
vector pool mapped to handle similarity searches, alongside dedicated memory for True Cache nodes. - Database Upgrade Path: If upgrading to 26ai from 19c, ensure compatibility checks for deprecated initialization parameters. If moving from 23ai, the transition is a simple Release Update without application re-certification.
Project Details with ExampleUse Case: Global E-Commerce & Recommendation EngineA retail giant runs an e-commerce platform across two ExaCC environments: Primary in New York (US-East) and Secondary in Frankfurt (EU-Central), replicated via Active Data Guard.- The Goal: Route analytical/AI recommendation searches (Vector queries) locally to reduce transatlantic latency, while dynamically shifting write transactions if a region fails.
- How GDS + 26ai Solves It:
- An application client requests an AI semantic search: "Find winter coats similar to this image text context."
- The GDS Connection Pool routes the query to the local Frankfurt standby database if the user is in Europe, utilizing Exadata AI Smart Scan to run the vector comparison at the storage layer.
- If replication lag exceeds a pre-defined threshold (e.g., 5 seconds), GDS automatically fails over the connection to the New York primary to prevent stale data visibility.
No comments:
Post a Comment