Oracle Database 26ai: What's New, Release History & Support Lifecycle

What Is New in Oracle AI Database 26ai

Oracle AI Database 26ai is the next long-term support (LTS) release of Oracle Database, shipping over 300 new features with a strong emphasis on in-database AI, developer productivity, and enterprise security. If you are planning upgrades or evaluating roadmap impact, this is the release worth planning around.

What is Oracle AI Vector Search in 26ai and how does it change production workloads?

Oracle AI Vector Search is now a first-class, production-grade feature of Oracle AI Database 26ai, allowing applications to perform semantic similarity searches alongside standard relational queries -- without moving data to a separate vector store. For teams already running Oracle, this eliminates the operational complexity of managing a dedicated vector database while retaining all existing security, HA, and transactional guarantees.

The most significant operational change in 26ai is that HNSW (Hierarchical Navigable Small World) indexes -- the fastest vector search index type Oracle offers -- now support full DML operations with transactional consistency. In earlier releases (23.4, 23.5), tables with HNSW indexes could not be updated. That restriction is gone. Queries against HNSW indexes now respect read snapshots, and consistency is maintained across all RAC instances.

Additional index improvements that matter in production:

• Hybrid Vector Index (HVI): A single DDL creates both a full-text Oracle Text index and a vector similarity index on the same column (including JSON columns). A unified query API lets you mix keyword, semantic, or hybrid queries. This is the right pattern for document search, customer support portals, and knowledge base applications.
• Distributed HNSW on RAC: The HNSW in-memory graph can now span multiple RAC instances, scaling the Vector Memory Pool beyond a single server's SGA limit. For large enterprise datasets, this removes a key capacity ceiling.
• Scalar Quantized HNSW: Compresses HNSW indexes using scalar quantization, significantly reducing the SGA Vector Pool footprint with minimal accuracy loss -- important when memory is constrained.
• Local Partitioned HNSW and IVF Indexes: Partition pruning now applies to vector indexes, making large partitioned datasets significantly faster to search.
• Online Index Rebuild: Both HNSW and IVF indexes can be created or rebuilt while the base table remains open for reads and writes. This matters if you cannot afford downtime during index maintenance windows.
• Auto IVF Reorganization: The system automatically detects centroid skew in IVF indexes and reorganizes without manual intervention.
• Included Columns in Vector Indexes: Non-vector columns can be stored inside HNSW and Neighbor Partition (IVF) indexes, eliminating the extra table access for attribute retrieval during similarity search.

Watch out for the COMPATIBLE parameter: you must set it to 23.6.0 or higher to enable new AI Vector Search features in 26ai. If your environment has older PDBs or standby databases still at a lower compatible setting, plan the migration sequence carefully before enabling vector features.

-- Example: Creating a Hybrid Vector Index on a text column
CREATE HYBRID VECTOR INDEX hvi_docs
  ON documents(doc_content)
  PARAMETERS ('model BERT_MODEL language english');

-- Querying with both keyword and semantic filters
SELECT doc_id, doc_title
FROM   documents
WHERE  CONTAINS(doc_content, 'invoice processing') > 0
ORDER BY VECTOR_DISTANCE(doc_embedding,
           TO_VECTOR(:query_embedding), COSINE)
FETCH APPROX FIRST 10 ROWS ONLY;

How does JavaScript stored procedure support work in Oracle Database 26ai?

Oracle AI Database 26ai ships a fully supported Multilingual Engine (MLE) for JavaScript, allowing developers to write stored procedures, functions, and triggers in JavaScript that run natively inside the database engine -- no external process, no round-trips, full access to Oracle data.

In practice, MLE JavaScript in 26ai works through two mechanisms: inline call specifications (for quick, self-contained functions) and MLE Modules (persistent JavaScript objects stored as schema objects). Modules are the right pattern for team-based development because they follow the same dependency and versioning model developers already use for client-side JavaScript. MLE Environments let you compose modules together and control which external APIs are available.

-- Create a persistent MLE module
CREATE OR REPLACE MLE MODULE inventory_utils
LANGUAGE JAVASCRIPT AS
$$
  export function applyDiscount(price, pct) {
    return price - (price * pct / 100);
  }
$$;

-- Expose it as a callable SQL/PL/SQL function
CREATE OR REPLACE FUNCTION apply_discount(p_price NUMBER, p_pct NUMBER)
  RETURN NUMBER
  AS MLE MODULE inventory_utils SIGNATURE 'applyDiscount(number, number)';

Key operational details for 26ai:

• No EXECUTE ON JAVASCRIPT privilege required: This is a breaking change for privilege auditing. Remove any grants of this privilege from your runbooks -- they are now no-ops, but their presence may confuse future auditors.
• Compile-time syntax checking: Inline call specifications now get syntax-checked at CREATE time, not at runtime. This catches errors earlier and is consistent with the checking already done for MLE modules.
• PURE execution contexts: Mark a JavaScript function with the PURE option to run it in a restricted context where it cannot modify tables or call PL/SQL packages. This is required for JavaScript user-defined vector distance functions on HNSW indexes.
• Foreign Function Interface (FFI): JavaScript code can now call PL/SQL code units using native JavaScript syntax instead of PL/SQL block wrappers. This significantly reduces boilerplate for mixed-language applications.
• Web API compatibility: Additional standard web APIs are exposed in the MLE JavaScript runtime, making it easier to reuse NPM libraries inside the database without writing custom polyfills.
• Post-execution debugging: Runtime state can be collected after execution for analysis, making it practical to diagnose bugs in production JavaScript code without modifying the observed logic.

Most teams will start with MLE Modules rather than inline call specs, particularly when the JavaScript logic will be shared across multiple PL/SQL packages or REST services. The module-and-environment model scales better and integrates cleanly with existing CI/CD pipelines.

What SQL and data type improvements ship in Oracle AI Database 26ai?

Oracle AI Database 26ai delivers a broad set of SQL language improvements that close long-standing gaps with other databases, reduce workaround complexity, and improve query expressiveness for both OLTP and analytics workloads.

SQL BOOLEAN data type: Native SQL BOOLEAN is now fully supported end to end -- DDL, DML, SELECT, PL/SQL, SQL*Plus, JDBC, ODBC, OCI, OCCI, and all precompilers. This eliminates the historical workaround of storing booleans as CHAR(1) or NUMBER(1) and the type coercion overhead that comes with it. Existing code using CHAR/NUMBER boolean patterns will continue to work, but new schemas should use the native type.

-- BOOLEAN column, SELECT without FROM, GROUP BY alias
CREATE TABLE orders (
    order_id   NUMBER,
    is_urgent  BOOLEAN DEFAULT FALSE,
    amount     NUMBER
);

SELECT is_urgent, SUM(amount) AS total_amount
FROM   orders
GROUP BY is_urgent;

-- SELECT without FROM (no DUAL needed)
SELECT SYSDATE, USER, SYS_GUID();

Other SQL changes with real operational impact:

• Direct Joins for UPDATE and DELETE: You can now join additional tables directly in UPDATE and DELETE statements without subqueries or inline views. This is a major readability and performance improvement for complex data manipulation.
• IF [NOT] EXISTS for DDL: CREATE TABLE IF NOT EXISTS and DROP TABLE IF EXISTS are now supported, eliminating the PL/SQL wrapper blocks that most teams use for idempotent schema migrations.
• Assertions (new constraint type): A powerful new multi-row constraint type that enforces data integrity rules that CHECK constraints cannot express -- such as ensuring total inventory across multiple rows never goes negative.
• Data Use Case Domains: Declare the semantic intent of a column (email, URL, currency, phone number) as a centralized schema object. Applications and tools can use domain metadata to auto-generate validation logic, reducing duplication.
• GROUP BY column alias or position, GROUP BY ALL, QUALIFY clause, Nested WITH, Table Value Constructor: These collectively bring Oracle SQL much closer to ANSI standard syntax supported by other databases, reducing friction when migrating queries from PostgreSQL, Snowflake, or similar systems.
• Automatic PL/SQL to SQL Transpiler: The optimizer can now automatically convert eligible PL/SQL functions to SQL expressions at parse time, avoiding context switch overhead without requiring code changes.
• DATEDIFF function, Calendar functions, Time Bucketing: Native date arithmetic functions that analytics teams have historically had to implement manually.
• UUID generation and testing via SQL: Built-in functions for UUID generation replace custom DBMS_CRYPTO or SYS_GUID workarounds in microservice-style applications.
• Unicode 15.0 Support: Updated character set support for global deployments.

How does Oracle Database 26ai improve security and access control for enterprise deployments?

Oracle AI Database 26ai ships the most significant set of security improvements in years, with SQL Firewall now bundled at no extra license cost, post-quantum cryptography support, TLS 1.3, multi-factor authentication, and a set of access control improvements that reduce the privilege creep problem that plagues large Oracle deployments.

SQL Firewall included: Oracle SQL Firewall is now part of the base Oracle AI Database 26ai license. It provides real-time monitoring and blocking of unauthorized SQL and SQL injection attacks regardless of execution path (application, direct connection, DB link). In prior releases this required a separate license. Most teams should plan to configure SQL Firewall allowlists as part of the 26ai upgrade cycle.

Schema-level privileges: System privileges (CREATE TABLE, CREATE INDEX, EXECUTE, etc.) can now be granted at the schema level rather than system-wide. This eliminates the longstanding pattern of over-granting system privileges to application accounts because object-level grants were too granular to manage. In practice, you can now grant CREATE TABLE only within a specific schema, which is the least-privilege model most security teams have always wanted.

-- Grant CREATE TABLE privilege scoped to a single schema
GRANT CREATE TABLE ON SCHEMA app_schema TO app_user;

-- New developer role for application teams
GRANT DB_DEVELOPER_ROLE TO app_developer;

DB_DEVELOPER_ROLE: A new predefined role bundles exactly the privileges application developers need to design, build, and deploy applications. This matters if you have been issuing ad-hoc privilege grants to dev accounts and want to standardize.

Encryption and authentication upgrades:

• TLS 1.3 is now supported. A new sqlnet.ora parameter lets you block deprecated cipher suites explicitly, which is important for compliance frameworks (PCI-DSS, FIPS).
• AES-XTS encryption mode is now supported for TDE tablespace encryption -- the current industry standard for block storage encryption.
• Post-Quantum Cryptography algorithms are available, allowing early adopters to begin testing quantum-resistant key exchange before the threat becomes practical.
• Multi-Factor Authentication (MFA) for database login is now natively supported.
• Microsoft Azure AD (Entra ID) OAuth2 SSO integration is extended to AIX, Solaris, and HPUX -- not just Linux and Windows.
• Database password maximum length is increased. Review any tooling or scripts that hardcode password field lengths.
• mkstore features are now part of orapki -- plan to update wallet management scripts.

This matters if you are running regulated workloads: the combination of SQL Firewall (now bundled), schema privileges, TLS 1.3, TDE with AES-XTS, and MFA means 26ai provides a meaningfully stronger security baseline out of the box than any prior Oracle release without additional license spend.

What high availability and developer productivity changes in Oracle AI Database 26ai affect day-to-day operations?

Oracle AI Database 26ai makes several changes that reduce DBA intervention in routine operations, improve availability for OLTP workloads, and extend JSON and microservice support to enterprise scale.

Priority Transactions: Low-priority transactions that are blocking high-priority transactions can now be automatically aborted by the database. This reduces the need for DBAs to manually identify and kill blocking sessions during peak load periods -- a task that usually happens at the worst possible moment.

Lock-Free Reservations: Applications can reserve part of a column value (such as an inventory count or account balance) without locking the row. This is a fundamental architectural improvement for high-concurrency OLTP scenarios like order management and financial systems where row-level locking causes hot-row contention.

Sessionless Transactions: Transactions can now be detached from a session, suspended, and resumed later by a different session. This is the right primitive for long-running workflows and microservice choreography where holding a database session open for the duration of a business transaction is not practical.

JSON Relational Duality Views -- production-ready: Duality Views let you expose the same underlying relational tables as either JSON documents or relational rows, with full transactional consistency in both directions. In 26ai this is extended with WHERE clauses, hidden and generated fields, calculated fields, GoldenGate replication support, and a JSON-to-Duality migration toolchain. For teams moving from MongoDB or document-store patterns, this is the path to keeping Oracle relational integrity without rewriting application data access layers.

Kafka APIs for TxEventQ: Existing Kafka producer and consumer code can now run against Oracle Transactional Event Queues (TxEventQ) with minimal code changes. This enables exactly-once messaging semantics backed by Oracle's transactional engine, which is a significant reliability improvement over standalone Kafka for workloads that require guaranteed delivery with database consistency. A migration tool is provided to move Classic Queues to TxEventQ online.

Data Guard per-PDB improvements: DML redirection, automatic standby PDB instantiation, automatic block repair, and per-PDB switchover/failover controls are all extended in 26ai. For large CDB deployments with dozens of PDBs, the ability to manage Data Guard at the PDB level rather than the CDB level is operationally significant -- it means individual PDB failovers without impacting the entire container.

Automatic Storage Compression and SecureFiles Shrink: The database can now automatically compress eligible segments and shrink SecureFiles LOBs without manual DBA intervention, reducing storage growth over time in environments with large volumes of LOB data.