Oracle MySQL HeatWave - Complete - Version 3

MySQL HeatWave
Automated, integrated, and secure Gen AI and
ML in one cloud service for transactions and
lakehouse scale analytics
Country Leader
Luca Bonesini
V 3.0

https://www.oracle.com/heatwave/
SIMPLE | AUTOMATED | SCALABLE | SECURE | PERFORMING | CHEAP
Copyright © 2025, Oracle and/or its affiliates
Generative AI
In-database LLMs
Automated,
in-database vector store
Scale-out
vector processing
HeatWave Chat
Machine Learning
In-database ML
Automated pipeline
to build ML models
Train models using
data in database and/or
object storage
MySQL
Accelerate MySQL queries
by orders of magnitude
Real-time analytics
without ETL/analytics DB
Advanced
security features
Lakehouse
Query data
in object storage
Unmatched performance
and price-performance
Optionally combine
with data in MySQL
ML-powered automation | Automatically improves performance and
price-performance | Increases the productivity of DBAs and developers
Autopilot
Multicloud

Helps you obtain the highest levels of MySQL performance, security, and reliability
MySQL Enterprise Edition
• Advanced security features for
encryption, data masking,
authentication, and a database
firewall
• Automated patching, upgrades,
backup, and high-availability
management. Access to the
latest MySQL features.
• Technical support provided by
the MySQL experts
HeatWave
• Integrated data processing
engine performing in-memory
query acceleration for MySQL
• Transparently improves MySQL
query performance by orders of
magnitude
• The HeatWave cluster can scale
out to handle peak loads and
scale back in when no longer
needed to reduce costs
MySQL HeatWave: Unique capabilities
HeatWave Autopilot
• ML-powered automation for
HeatWave and MySQL Database
• Automatically improves
performance, without requiring
tuning expertise, and price
performance
• Increases the productivity of
developers and DBAs, and helps
eliminate human errors

Query half a PB data in the object store, in a variety of file formats
MySQL HeatWave Lakehouse
• Query data in object storage in various
formats: CSV, Parquet, Avro, JSON, and
exports from other databases—using
standard SQL syntax
• Optionally combine it with data in
MySQL
• Scale-out data processing in the object
store. Data is not copied to the MySQL
Database: for both MySQL and non-
MySQL workloads
• Up to 500 TB of data—the HeatWave
cluster scales to 512 nodes
• Easily build and train ML models with all
your data using HeatWave AutoML
Optional

Train ML models using data in the database and object storage
MySQL HeatWave AutoML enables a wide range of use cases
Regression
Time-series
forecasting
Anomaly
detection
Classification
Recommender System
Predict advertising
spend ROI
Demand forecasting
Detect anomalous
credit card spend
Identify game hacker
Identify similar users
Loan default
prediction
Predict flight delay
Rainfall prediction
Recommend movies
Database Data
Object Store
Data
Database
Exports
Predictions are
delivered with
an explanation
to understand,
trust, and
explain results

RAG and similarity
search
• Use GenAI with your
organization’s data
(Retrieval Augmented
Generation)
to get more accurate and
contextually relevant
answers
• Perform similarity searches
on unstructured data
Content generation and
summarization
• Generate insights/reports
from enterprise
documents
• Generate blogs from PDF
instruction manuals
• Summarize content
MySQL HeatWave GenAI enables new use cases and apps
Synergy of integrated
GenAI and ML
• Save time and deliver
more value to customers
by combining ML and
GenAI
• Help reduce costs and get
more accurate results
faster by using GenAI on
data filtered by AutoML
Conversations in natural
language
• Conversations informed
by your unstructured
documents using natural
language
• HeatWave Chat preserves
context for follow-up
questions
+

High query performance at scale, higher OLTP throughput, and the best price performance
MySQL HeatWave Autopilot: machine learning-powered automation
HeatWave

Multiple use cases across industries
Finance
Fraud Detection
Detect patterns indicative of
fraudulent activities
Risk Management
Assess and manage financial risks,
incorporating historical and real-
time information
Telecom
Network Optimization
Analyze performance data,
customer feedback, and service
logs to optimize network
infrastructure
Churn Prediction
Predict and prevent churn,
improving customer retention
strategies
Healthcare
Patient Analytics
Analyze patient records, medical
images, and genomic data to
derive insights for personalized
medicine and treatment plans.
Clinical Research
Clinical trials, aggregating diverse
datasets for research purposes
Retail
Customer Analytics
Analyze customer behavior and
purchase history for personalized
messages
Supply Chain Optimization
Use raw logistics data, to optimize
inventory levels, reduce costs, and
improve delivery times
Energy
Smart Grid Analytics
Analyze data from sensors and
weather forecasts to optimize
energy distribution
Asset Management
Predictive maintenance and
optimal asset utilization
Manufacturing
Predictive Maintenance
Analyze sensor data from
machinery to predict and prevent
equipment failures
Quality Control
Monitor and improve product
quality throughout the
manufacturing process
Ecommerce
Recommendation Engine
Using various data for personalized
product recommendations
Marketing Attribution
Determine the impact of marketing
campaigns
Government
Public Safety
Integrating data from various
sources for better situational
awareness and response during
crises
Policy Planning
Analyzing demographic, economic,
and social data planning and
decision-making

MySQL HeatWave is significantly less expensive
$0
$500
$1,000
$1,500
$2,000
$2,500
$3,000
$3,500
$4,000
Amazon RDS for MySQL Amazon Aurora Google Cloud SQL for MySQL Azure Database for MySQL HeatWave MySQL
MySQL cloud services comparison
Monthly cost for OLTP application; 32 vCPUs, 256 GB memory, 1 TB storage
Source: https://blogs.oracle.com/mysql/post/mysql-cloud-services-cost-comparison-who-provides-the-best-value-2025

11X better than Redshift, 15X better than Databricks, 19X better than Snowflake, 22X faster than BigQuery
Query price-performance of MySQL HeatWave Lakehouse
0
500
1000
1500
2000
2500
3000
3500
HeatWave Lakehouse Redshift Databricks Snowflake Google BigQuery
Price-performance
Price-performance: 500 TB TPC-H
11X higher
15X higher
19X higher
22X higher
Benchmark queries are
derived from the TPC-H
benchmarks, but results are
not comparable to published
TPC-H benchmark results
since these do not comply
with the TPC-H specifications.
Configuration:
• MySQL HeatWave
Lakehouse: 512 nodes;
• Snowflake: 4X-Large
Cluster;
• Databricks: 3X-Large
Cluster;
• Amazon Redshift: 20-
ra3.16xlarge;
• Google BigQuery: 6400
slots
Significantly
lower cost

MySQL HeatWave Native Integration, Key Business Benefits
§ Unified Management
§ MySQL DB Systems managed
together with compute, storage, OKE
cluster, and networking in
§ Full Stack DR plans
§ Built-in Intelligence
§ Native integration adds automated
pre-checks and error handling,
increasing DR reliability
§ Enterprise Reliability
§ Includes logging, monitoring, and
audit trails to ensure transparency
and compliance
§ Faster Recovery
§ Automated recovery reduces
Recovery Time Objective (RTO) for
MySQL-dependent systems
OCI Full Stack Disaster Recovery
OCI FULL STACK DR

Push Button Recovery
Orchestrate end-to-end recovery with Full Stack DR
Minimize effort
Define which OCI compute, storage, and databases belong to an
application stack, then build fully functional DR Plans in minutes
Customize runbooks
Tailor DR Plans to recover Oracle & non-Oracle applications
along with anything else unique to your environment
Validate runbook integrity
Fully automated, non-intrusive, non-disruptive DR drills using a
single button are built into the service
Simple execution
Operators can recover many critical business systems at the
same time without knowing anything about the steps needed to
recover
Simple implementation
Automate the recovery steps for business systems already
deployed for DR without redesigning or reinstalling your
application stack
Virtual Machine
Exadata
ExaDB-CS
Base Database
BaseDB
Virtual Cloud Network
VCN
Exadata Exascale
ExaDB-XS
Autonomous Exadata C@C
ADB-CC
Load Balancer
LBR
File Storage
FSS
Block Storage
BSS
Object Storage
OSS
Dedicated VM Host
DVH
MySQL
MDS
Integration
OIC
coming soon
Kubernetes Engine
OKE
Dedicated Region C@C
DRCC
Alloy
Exadata C@C
ExaDB-CC
Autonomous Dedicated
ADB-D
Autonomous Serverless
ADB-S
OCI PostgreSQL
coming soon
Full Stack DR
GoldenGate
GG
coming soon
OCI FULL STACK DR

Inbound Channel Replication setup and Pre-requisites
1. Set Up Networking
• Create Dynamic Routing Gateways (DRGs) in both
regions and establish remote peering
• Update Virtual Cloud Network (VCN) route tables to
direct traffic through DRGs
• Adjust security lists and Network Security Groups
(NSGs) to allow replication traffic
2. Deploy DB Systems
• Set up a MySQL HeatWave DB system in the source
region and create a replication user
• Back up the primary database and copy it to the
target region using the Copy Backup feature
• Restore the backup in the target region to create a
standby DB system and set it to Read Only
3. Configure Replication
• Set up the replication channel with the source DB
hostname, port, and replication user credentials
• Regularly check replication status and run data
consistency checks to ensure integrity
OCI FULL STACK DR

Backup Validation
Enable customers to verify data restorability and backup consistency
Why it matters
Disaster Recovery Readiness
• Validating backups for restorability ensures
organizations are prepared for outages and
ransomware events.
Compliance Requirement
• Many regulations and frameworks require
not only backups, but regular restore testing
(e.g., HIPAA, ISO/IEC 27001, NIST)
Competitors Recommend Backup Validation
• AWS: Recovery testing
• Google Cloud: Recommends testing
restoration processes
• Microsoft Azure: Recommends Recovery
Services Vault and validating backups
against ransomware
What’s unique
Single-Click Validation
• Simple, guided workflow to initiate
verification
Verifies Complete Restore Process
• Confirms host image integrity and data
consistency end-to-end
Faster Future Restore
• Prepares backups with undo/redo applied to
minimize downtime during recovery
Future Restore Time Estimate
• Provides estimated restore duration per
validated backup
Time Saved Insight
• Highlights time saved when restoring from a
prepared backup
BACKUP VALIDATION

BYOK – Customer Managed Encryption
Use your own keys to secure MySQL HeatWave Data
• Customer Control over Encryption
• Control and manage the encryption keys used to secure their sensitive data,
rather than relying solely on Oracle-managed keys.
• Compliance and Security Response
• Rotate the encryption keys regularly to meet compliance requirements. Also
rotate keys during suspected security events to protect data.
• Integration with Oracle Cloud Vault
• Select a key from Oracle Cloud Vault, giving you authority over the key
lifecycle (creation, rotation, disabling, deletion).
• Data Protection
• Encryption ensures that even if the physical storage is compromised,
sensitive data remains unreadable without the appropriate encryption key.
• User-Controlled Key Lifecycle
• Gain control over encryption and decryption
BYOK

New Features for ML/GenAI
Text to SQL aka NL2SQL: Query the database in natural language
- Call sys.nl_sql(“How many airports are there”, @output, ‘{"model_id":"llama3.2-3b-instruct-v1"}’);
NL2ML: Get guidance on using an AutoML feature
- describe your use case, and NL2ML guides you step-by-step through the ML workflow.
Integration with OCI Services
• Vision Language Models (VLMs)
• OCI GenAI Dedicated cluster support
• OCI Agentic Service
• Use OCI Embedding models
Summarize documents
• Generate a summary of a document in object store
Sample MCP server for MySQL HeatWave
• Added tools for MySQL HeatWave to the sample code in https://github.com/oracle/mcp
NL2SQL/NL2ML

Benefits:
• Simplified Data Access
• NL_SQL eliminates the need for complex SQL queries, making
it easier for non-technical users to access and analyze data.
• Increased Productivity
• Users can focus on higher-level tasks, such as data analysis
and insights, rather than spending time writing SQL queries
• Improved Accuracy
• NL_SQL reduces the likelihood of SQL syntax errors, ensuring
accurate results and minimizing the need for manual
debugging.
• Enhanced Collaboration
• NL_SQL enables users to share and collaborate on data
analysis tasks more effectively, regardless of their technical
expertise
Natural Language to SQL NL2SQL
HeatWave NL_SQL
a groundbreaking
feature that enables
users to query
databases using
natural language

CALL sys.NL_SQL(...) NL2SQL
https://blogs.oracle.com/mysql/post/introducing-natural-language-to-sql-for-mysql-heatwave

CALL sys.NL_SQL("What is the total number of bookings priced over
$200?", @output, '{"schemas":["airportdb"]}’);
+---------------------------------------------------------------------------+
| Executing generated SQL statement... |
+---------------------------------------------------------------------------+
| SELECT COUNT(`booking_id`) FROM `airportdb`.`booking` WHERE `price` > 200 |
+---------------------------------------------------------------------------+
+---------------------+
| COUNT(`booking_id`) |
+---------------------+
| 32699080 |
+---------------------+
Call sys.NL_SQL(...) NL2SQL

An innovative way to work
with document-centric
applications without
abandoning the strengths
of relational databases
Simplify Application Stack
• Unified access, say
goodbye to ETL and sync
hassles
• No more ORM or data
mapping glue
• Seamless data evolution
and migration
JSON Relational Duality Views JSON

MySQL REST Service
https://blogs.oracle.com/mysql/post/announcing-general-availability-of-the-new-heatwave-rest-service
BEFORE
AFTER
Full REST Stack Support
• Application stacks can be simplified by
eliminating middleware, and sometimes the
entire application backend. This lets your
applications interact directly and securely with
your data through standard HTTP requests.
• Develop powerful Progressive Web Apps
(PWAs) by using JavaScript on all layers: inside
the MySQL server, the router, and the client.
Made for Modern AI Application Development
• Take full advantage of HeatWave Generative
AI and Machine Learning capabilities to
integrate AI features into existing and new
applications.
• Develop GenAI apps that rely on in-database
LLMs in HeatWave to eliminate the need for
additional software or hardware and reduce
costs.
• Increase data security by moving all data
processing, including LLM and REST handling,
into the MySQL server.
REST SERVICE

Network Security Groups
https://blogs.oracle.com/mysql/post/enhancing-security-in-oci-using-network-security-groups-heatwave-mysql
Fine-grained, workload-level
network security
• NSGs are supported for both
primary DB systems and their
Read Replicas (RR)
• Each DB system or Read Replica
can be associated with up to 5
NSGs
• NSGs are tied to the customer-
managed VNICs of the selected
DB systems or Read Replicas. Any
traffic to the database will be
filtered based on the rules
defined in those NSGs
• For DB systems with a Read
Replica, the private endpoint of
the Replica's Network Load
Balancer (NLB) will honor the
NSG configuration applied to the
DB system
NSG

Transparent Data Encryption (TDE)
https://blogs.oracle.com/mysql/post/heatwave-mysql-security-transparent-data-encryption
Protects sensitive data at rest by encrypting database files
at the storage level without requiring application changes
TDE

DB System Read Endpoint
https://blogs.oracle.com/mysql/post/optimize-database-performance-with-heatwaves-enhanced-read-operations
Enhance read
scalability,
configurability and
performance for
applications
Advantages:
• Single Read Endpoint
• Customizable Endpoint
Configuration
• Automatic Fallback
• Command Query
Responsibility Segregation
(CQRS)
• Built-in Monitoring and
Management
• Exclusion of Specific
Replicas
DB SYS READ ENDPOINT

Database Mode and Access Mode
https://blogs.oracle.com/mysql/post/enhance-data-protection-in-heatwave
Configure a database
as read-only to
preserve its data
integrity, protecting it
against undesired data
changes:
• Historic or archive
purposes
• Maintenance and
security
• Disaster Recovery (DR)
DB MODE ACCESS

Cross-Region Oracle Disaster Recovery Copy in OCI
https://blogs.oracle.com/mysql/post/set-up-crossregion-oracle-heatwave-mysql-disaster-recovery-copy-in-oci
CROSS REGION DR

Proactive Backup Monitoring
https://blogs.oracle.com/mysql/post/heatwave-service-proactive-backup-monitoring
OCI’s Monitoring
and Alarm services
provide a robust
solution for tracking
backup
performance and
instantly alerting
administrators in
case of failures:
• alarms for
backup failures in
HeatWave DB
systems
• immediate
notifications of
backup failures
BACKUP MONITORING

And the most popular database for developers
MySQL is the #1 Open Source Database
18%
25%
26%
27%
38%
51%
MS SQL Server
SQLite
Redis
MongoDB
PostgreSQL
MySQL
Which databases have you used in the last 12 months?
Jetbrains developer survey 2025

Either on-premises or in the cloud
• MySQL is typically adopted by developers to rapidly implement
internal and customer-facing apps
• Self-managed databases can however create risks, especially as app
usage grows:
• Data protection
• Regulatory compliance
• High Availability
• Backups
• Ability to get immediate technical support
• Performance and scalability are often not optimized
• Apps can run older MySQL versions, without the latest features
Challenges with self-managed MySQL databases
60%
of data
breaches are
due to
unapplied
patches
https://www.orbital10.co.uk/the-patch-stats

MySQL HeatWave
Cluster, In-Memory DB

MySQL HeatWave transparently improves query performance
Transactions are replicated
in real-time to HeatWave
The MySQL query optimizer
transparently decides if
queries should be
offloaded to HeatWave for
accelerated execution
No changes are required to
existing applications
InnoDB
storage
engine
HeatWave
Applications

In-memory query accelerator – convert to columnar format and real-time
MySQL HeatWave
MySQL Database Service
Analytic
Query
Query
Results
MySQL Compiler & Optimizer
Analytic Query
Optimization
Query
Pushdown
Insert/
Update
OLTP Query
Optimization
Real Time
Update
InnodB
MySQL Execution
HeatWave Cluster (In-Memory)
In-Memory Representation
Analytic Query Execution
Analytic Job Scheduler
Results
Data converted into columnar format and stored in memory.
HeatWave - query accelerator speed up query performance
for real time analytics

In-Memory hybrid columnar processing

Massively parallel architecture
• High-fanout partitioning
• Machines & CPU cores can further process partitioned data in parallel
• Optimized for cache size and memory hierarchy of underlying hardware

Lowers costs and improves flexibility
• Increase/decrease your HeatWave cluster size by any number of nodes
• Not constrained by fixed shape ‘T-shirt’ sizes
• Pay for the exact resources you use
• Flexibility to handle peak loads
• Queries are executed while resizing
• No downtime/read-only time
• No performance degradation
due to resizing
Real-time elasticity to any number of HeatWave nodes
“We view Snowflake costs as extremely high as the
company forces users to select “T-shirt/shoe sizes,” in
increments of 16, 32 or 128 nodes.“

Query Acceleration OFF: example #1

Query Acceleration ON: example #1

Query Acceleration Result: example #1
0.1267 sec
vs
1.2717 sec
10x faster
only 1 day of
data

Query Acceleration Result: example #2
14 days of data
11GB
69M ROWS
383x
faster

MySQL HeatWave POC Results
Query SQL Statements RDS HeatWave Time Accelerated
1
SELECT '1' AS TABLE_NUM, AL' AS TABLE_NAME, 'FIP' AS ENTITY_TYPE,FID as ENTITY_ID,
count(*) as count from UA as ua where ua.UA >= ‘1000’' AND ua.userAccountID <=(SELECT
UAID FROM UA WHERE UTS < [DATE1]' order by UA desc limit 1 ) and ua.FID NOT LIKE
‘%@ON%' and ua.status = 'linked' group by ua.FID;
12Min 30sec 8.31 sec 90x
2
SELECT '2' AS TABLE_NUM, ‘TableA'' AS TABLE_NAME, 'FIU' AS ENTITY_TYPE, DID AS
ENTITY_ID, COUNT(*) AS count FROM CL as cl LEFT OUTER join CA as ca ON ca.CH = cl.CH and
ca.DCT =”ABC" WHERE (cl.id >= ‘1000' AND cl.id <= (SELECT id FROM CL WHERE TS <
‘[DATE1]' order by id desc limit 1)) AND (cl.fetch_type = 'ONETIME' or ((cl.FT="PERIODIC" and
cl.PCODE != '104') or (cl.PCODE= ‘200' &&
cl.fetch_type="PERIODIC" and ca.CUC > 0 and ca.id >= ‘1000' and ca.id <= (SELECT id FROM CA
WHERE
CULD < ‘[DATE2]' order by id desc limit 1)))) AND cl.ID NOT LIKE ‘%@ON%' GROUP BY
ENTITY_ID;
4Hr 54.02 sec 267x
3
SELECT '8' AS TABLE_NUM, ‘AWT' AS TABLE_NAME, 'FIP' AS ET,fi.NID as EID,
AVG(TIME_TO_SEC(TIMEDIFF(fi.CA,fdr.CA))) AS count from fi_NID as fi, fDR as fdr where fi.CA
>= ‘[DATE1]' AND fi.CA < ‘[DATE2]' AND fi.SID = fdr.SID AND fi.NT IN ('FIP') AND fi.NID NOT
LIKE ‘%@ON%' group by EID;
40Min 4sec 36000x

MySQL HeatWave
High Availability, Backup

MySQL DB System

High Availability

Backup Automatico in Cloud
• Backup Integrati: con MySQL HeatWave, i backup sono eseguiti in modo nativo
e automatico nell’ambiente Oracle Cloud
• Semplicità: non è necessario configurare script o pianificare backup manuali.
L’infrastruttura gestisce tutto in background, semplificando notevolmente il
setup
• Efficienza: backup incrementali e compressione dati per ridurre i tempi e
ottimizzare lo storage
Vantaggi dei Backup con HeatWave MySQL
• Zero manutenzione manuale: l’automazione gestisce tutti i backup e le
rotazioni, riducendo il carico di lavoro del team IT
• Sicurezza dei dati: i backup sono protetti tramite cifratura, garantendo la
conformità con le normative di sicurezza
• Disponibilità continua: anche durante il recupero, il database rimane disponibile,
evitando downtime e mantenendo l’operatività
Backup: la PITR non è mai stata così semplice

Backup: la PITR non è mai stata così semplice
• Recupero veloce e senza interruzioni: la procedura è automatizzata e
non richiede competenze avanzate
• Finestra di recupero personalizzabile: possibilità di definire quanto a
lungo conservare i dati per il PITR, bilanciando costo e protezione
Cos’è il PITR?
Il PITR permette di ripristinare i dati
esattamente a uno specifico momento nel
passato. È ideale per correggere errori
umani o per il recupero rapido da incidenti.
Implementazione in HeatWave:
• Facile da usare: gli utenti possono
configurare il PITR direttamente dalla
console, specificando l’orario preciso
per il recupero

Auto Query Plan Improvement
Optimizer learns and improves query plan based on queries executed earlier
A B
C
⨝
⨝
Node Statistics
A 70
B 150
A ⨝ B 1000
C …
A ⨝ B ⨝ C …
A B
D
∪
⨝
Runtime statistics
• Traditional caching techniques are not intelligent
• With Autopilot, system gets better as more queries are run
• For example, Autopilot improves TPCH, TPCDS 24TB performance by 40%
GenAI
MySQL
Lakehouse
AutoML

Improves adhoc query performance and skew handling
• Dynamically adjusts data structures and
system resources after query execution has
started
• Independently optimizes query execution
for each node based on actual data
distribution at run time
Adaptive query execution in MySQL HeatWave
Part
Stats Collection
Adjust Plan
Operator
Part
Stats Collection
Adjust Plan
Operator
Collected Statistics are exchanged
with data
Workload Data size Improvement in first run
TPCDS 2TB 21%
TPCDS 16TB 25%
TPCDS 100TB 10%

Auto provisioning with MySQL HeatWave Lakehouse
How to determine the right cluster size required for processing data in object store?

Auto schema inference with MySQL HeatWave Lakehouse
…Even for files that don’t have metadata! Attribute name, data type, precision, and length

STANDARD SQL syntax generated by HeatWave Autopilot, no human required
1.System Setup
Ø Run HeatWave Autopilot on object store to
determine cluster size and schema mapping
Ø Execute DDLs generated by Autopilot
2.Run query across files and tables
Ømysql> SELECT count(*) FROM Sensor, SALES WHERE
Sensor.degrees > 30 AND Sensor.date = SALES.date;
Very simple to query files in the object store
HeatWave

• Automatically loads tables or columns into HeatWave to optimize performance of user workload
• Automatically unloads tables less frequently used than other tables to optimize performance without
increasing cost
Auto load and unload
MySQL
Database
HeatWave
Cluster
LOAD
UNLOAD
Workloads
Frees developers
from manually
loading/unloading
tables

Recommends secondary indexes for OLTP workloads
MySQL HeatWave Autopilot indexing
CREATE /
DROP
Indexes
index
Queries DMLs
Tables
Queries DMLs
HeatWave

Similar or better performance than manually tuned workload
MySQL HeatWave Autopilot indexing results
0
5000
10000
15000
20000
25000
TPCC Benchbase (SF13) SMALLBANK (SF7) SEATS (SF7) EPINIONS (SF350) AUCTIONMARK (SF8)
Requests/second
Benchmark - throughput
Tuned Benchmark
Autopilot Indexing
• MySQL Autopilot recommends indexes whose performance is at par or better than manually tuned benchmarks
• In some cases, Autopilot recommends fewer indexes, which saves storage costs and improves DML performance

Complex and analytics queries
MySQL HeatWave vs. Amazon Aurora and RDS for MySQL
0
50000
100000
150000
200000
250000
300000
350000
400000
450000
500000
HeatWave MySQL (4 nodes) Aurora (db.r5.24xlarge)
Time
in
seconds
Query performance: 4 TB TPC-H
1,400X
slower
*Benchmark queries are derived from the TPC-H benchmarks, but results are not comparable to published TPC-H benchmark results since these do not comply with the TPC-H specifications.
2,200X
worse
2,200X worse price-performance
0
200000
400000
600000
800000
1000000
1200000
1400000
HeatWave MySQL (4 nodes) Amazon RDS for MySQL
(db.r5.24xlarge)
Time
in
seconds
Query Performance: 4 TB TPC-H
4,600X worse price-performance
3500X
slower
Amazon Aurora Amazon RDS

Organizations embrace multi-cloud
Key drivers
• Data sovereignty/locality
• Best-of-breed cloud services
• Cost optimization
• Disaster recovery
• Cloud vendor lock-in
concerns
98%
Use 2 cloud
providers or more
Sources: S&P Multicloud in the Mainstream Global Survey, 2025; Flexera 2025 State of the cloud report

Replace up to 6 AWS services with ONE
• HeatWave runs natively on AWS, optimized for
AWS infrastructure. Delivers 7X better price-
performance than Amazon Redshift on AWS.
• Keep data in AWS: no egress costs, low latency,
and easier migrations from other databases on
AWS
• Integration with other AWS services (e.g., S3,
CloudWatch, PrivateLink)
MySQL HeatWave on AWS
Source: https://www.oracle.com/mysql/heatwave/performance-benchmarks/#heatwave-on-aws

MySQL HeatWave on AWS
Data plane, control plane, and console run in AWS
Transaction
Processing
Warehouse
Analytics
Machine
Learning
Oracle AWS Account
Customer AWS Account
Applications
Data
cloud.mysql.com
MySQL user
Console
Control plane
Data plane
Lakehouse
Generative AI

OCI Dedicated Region
Available in your data center
Self-contained cloud region
HeatWave and all Oracle public cloud
services in your data center
Public cloud economics and security
Meet data residency and latency
requirements

Enabling hybrid deployments
OLTP on-premises, analytics in the cloud

MySQL HeatWave makes security easy
Oracle CloudWorld Copyright © 2025, Oracle and/or its affiliates
• Data remains in one database system
• Uniform access controls and single configuration
• All communication is authenticated and encrypted
• Large surface area of data movement and exposure
• Different services with varying security postures: encryption
keys, user access, authentication schemes
• User needs to configure, connect varied services
User
data
Apps
HeatWave
Other Services MySQL HeatWave
Analytics
OLTP
Vector
store
LLM
Machine
Learning
Lakehouse

“VRGlass migrated all application data to
HeatWave MySQL from AWS EC2. Within
three hours, we achieved a 5x increase in
database performance for a virtual event
that accommodated more than 1 million
visitors and 1.7 million sessions with greater
security and at the half the cost.”
Ohmar Tacla
CEO, VRGlass
Business Challenge:
VRGlass is Brasilian SaaS startup that produces metaverse
apps and equipment for 3D virtual stores and NFTs for
business audiences. It needed to find a platform that was
easy to set up, scalable, and secure to host virtual events for
massive crowds and tracks 150 data points from each user.
Products Used:
HeatWave MySQL
Results:
Migrated to HeatWave MySQL from AWS EC2 and
Digital Ocean in three hours
5X faster performance that processed 8,000 registrations
per minute with real-time analytics
Reduced costs by 50% with pay-per-use pricing and
HeatWave Autopilot
Enhanced security
Scales to 1 million visitors and 1.7 million sessions
Reduced sales cycles from 9 months to 2 months and
increased sales by 500% in one month
Read story
VRGlass grows metaverse
with HeatWave MySQL

Wavenet enhanced query
performance while saving 30%
Challenge:
With the goal to enable customers to track and fine-tune marketing activities
24/7 in real-time, the leading digital marketing company in Asia Pacific region
Wavenet Technology needed a high-performant, secure, and affordable
database to support the growing capacity and demand. ETL became too time
consuming, and customers waited several minutes for their queries with
Amazon Redshift. They migrated from Redshift to HeatWave MySQL.
Products Used:
HeatWave MySQL
“Oracle HeatWave MySQL provides us with a very
efficient and fast way to explore and use data. We
can now run more than one million customer
dashboard queries in a few seconds. Plus, by
moving from AWS Redshift to HeatWave MySQL,
we have reduced our total cost of ownership by at
least 30%.”
Hung Chih Chieh, Chief Technology Officer, Wavenet Technology
Results:
Eliminated ETL processes and simplified data management with one
database for transactions and analytics
Reduced TCO by 30%
Slashed query response time from minutes to seconds for more
sophisticated analysis
HeatWave Autopilot dynamically configures parameters to optimize
query performance
Improved ability to develop new automated marketing solutions
Read story

Effectively querying data in object storage is critical
Massive growth of data outside of databases
Source: https://bigdataanalyticsnews.com/big-data-statistics/
>80%
of the data
generated is
unstructured
of organizations say
managing
unstructured data is
a significant
problem
95%

Massive amount of data stored in files
Increased Data Volumes: a Rise in Object Storage Popularity
Businesses confront unprecedented volumes of data
• 79 Zettabytes of data generated in 2021, 180 ZB expected 2025
“Data Lake:” Object store has become a preferred method for cost-
effective large-scale data storage and management:
• Houses file-based data, e.g. IoT, web content, log files
• Flat architecture: holds data in its raw, native format
Database and Data Warehouse are systems of record
• Houses transactional data used for daily operations; essential for
reporting, projections, e.g. financial transaction systems, online
reservation bookings, inventory control
• Organized into structured rows and columns
Object Store
Social
Events
Devices
Sensors
Need to analyze data across database and object store to gain meaningful business insights

Lack of time, resources, and expertise to process different data formats across different data sources
99.5% of collected data remains unused. Why?
The challenge:
• Data in object store not easily organized into a traditional relational database with rows and columns
• Complex, expensive, and time-intensive to transform file data from object store into OLTP data structures for
processing and analysis alongside transactional data within the database
The solution:
What is a Data Lakehouse?
Best of both worlds:
• Affordable data repository to collect data from both structured and unstructured sources
• Database tools and features to prepare and organize data for business use cases such as analysis,
reporting and projections
• Accelerates analysis of data across different formats
Data Lake Data Warehouse Data Lakehouse

Query half a PB data in the object store, in a variety of file formats
MySQL HeatWave Lakehouse
• Query data in object storage in various
formats: CSV, Parquet, Avro, JSON, and
exports from other databases—using
standard SQL syntax
• Optionally combine it with data in
MySQL
• Scale-out data processing in the object
store. Data is not copied to the MySQL
Database: for both MySQL and non-
MySQL workloads
• Up to 500 TB of data—the HeatWave
cluster scales to 512 nodes
• Easily use GenAI and ML with all your
data
Optional

Banking use-case: insights on historical financial data
On-premises Object storage
HeatWave
Lakehouse
Users
Data is exported as CSV
files to object storage.
HeatWave Lakehouse
enables fast queries on
data in object storage.
Users get rapid and
cost-effective insights
from historical
transactions data.
Costly to retain all
historical transactions
data in transactional
database for analytics.

Digital marketing use-case: insights across all campaign data
HeatWave MySQL Object storage
HeatWave
Lakehouse
Users
Older campaign data is
exported to a data lake.
All campaign data is
stored in HeatWave
MySQL.
HeatWave Lakehouse
can query recent data
combined with older
campaign data.
Users can run analytics
queries across all
campaign data.

Media use-case: insights across aggregated book sales and data
Transactional
data
Object storage
HeatWave
Lakehouse
Users
HeatWave Lakehouse
can query transactional
data combined with
data in object storage.
Users can effectively
manage and plan sales
campaigns.
Daily sales and
campaign data
HeatWave MySQL
Book sales are recorded.
Data is stored in the
transactional database.
Statistics on sales and
campaigns are gathered.
Data is exported as CSV
files to object storage.

IoT use case: analytics dashboards and chatbots
Ships Object storage
HeatWave
Lakehouse
Applications
IoT data is stored as
CSV files in a data lake.
HeatWave Lakehouse
can rapidly query this
data.
Users can implement
analytics dashboards
and chatbots accessing
IoT data.
Data is generated from
IoT sensors on shipping
containers.

MySQL HeatWave scales out
1 120 512 250
Scale to any cluster size
• Flexible cluster size up to
512 HeatWave nodes
• Scale to any size based on
workload and performance
requirements
Fast provisioning High Scale Factor
• Provision cluster in less than
16 mins for up to 512 nodes
• Pause & resume cluster to
minimize cost
• Load performance scales with
cluster size
• Query performance scales
with cluster size
Flexible, fast and highly scalable

Use HeatWave Lakehouse to process semi-structured data
• JSON data in CSV, Parquet, and Avro file formats can now be processed by
HeatWave
• Support extended to newline-delimited JSON files
o Ease of parsing and streaming has made it the most popular JSON format
• NDJSON data ingestion and processing scales similarly to structured file formats
…
{ “name”: “Jane”, “academics”: { "undergraduate": "MIT", "graduate": "UT Austin” }, "age": 24 }
{ “name”: “Jill”, “academics”: { "undergraduate": ”Madison", "graduate": ”Stanford” }, "age": 27 }
…
Example NDJSON file

Run JavaScript on files in object store
User Bucket
Ingest into
Lakehouse
table
Read Lakehouse
table data
MySQL
MySQL
Client
(Stored
Procedure)
HeatWave
Results Lakehouse Tables
JavaScript
execution
JavaScript
Query

High write performance enables new use cases including MapReduce
Query results can be written to object store

Super chunking helps achieve good scalability during load
Data loading scales out
• Data copied to object store
• Adaptive data flow helps use max available bandwidth
N2
C1 C2
C3 CN
…
…
N1
C1 C2
C3 CN
…
N3
C1 C2
C3 CN
…
NM
C1 C2
C3 CN
…
…
Super
chunking
Dynamic Allocation
Balancing
Compute
Nodes
Data
• Statistics collected and aggregated
• Data transformed into hybrid columnar format

Building MapReduce applications is easier with HeatWave
Need to manually estimate and provision a
compute cluster
Complex configuration - #maps, #reduces
No built-in ACID guarantees
Expressing data processing logic is
complex in non-SQL languages
HeatWave AutoPilot recommends the
optimal configuration
HeatWave automatically tunes and advises
Mature database with ACID compliance
Manipulating data is easier using SQL
MapReduce HeatWave

Query performance of HeatWave Lakehouse
0
10,000
20,000
30,000
40,000
50,000
60,000
70,000
80,000
HeatWave Lakehouse Amazon Redshift Databricks Snowflake Google BigQuery
Total
execution
time
in
seconds
Query execution time: 500 TB TPC-H
18X slower
18X slower
35X slower
15X slower
Configuration:
• MySQL HeatWave
Cluster;
Cluster;
ra3.16xlarge;
slots
Significantly
reduces time-
to-insights
Querying data in object storage is as fast as querying the databases – an industry-first

11X better than Redshift, 15X better than Databricks, 19X better than Snowflake, 22X faster than BigQuery
Query price-performance of HeatWave Lakehouse
0
500
1000
1500
2000
2500
3000
3500
HeatWave Lakehouse Redshift Databricks Snowflake Google BigQuery
Price-performance
Price-performance: 500 TB TPC-H
11X higher
15X higher
19X higher
22X higher
Configuration:
• MySQL HeatWave
Cluster;
Cluster;
ra3.16xlarge;
slots
Significantly
lower cost

“HeatWave Lakehouse scales out very well for
loading data from object storage and for
running queries on object store… This scale out
characteristic of HeatWave Lakehouse for data
management is key to efficiently process very
large amounts of data.”
Henry Tullis
Leader, Cloud Infrastructure and Engineering
Deloitte Consulting
Takashi Kinoshita
Chief Producer, e-Book Division
NTT SOLMARE Corporation
“HeatWave Lakehouse allows us to easily
and quickly load data on object storage
into HeatWave and combine it with
MySQL data for analysis.”

Estuda.com achieves real-time
insights
Business Challenge:
Brasil’s leading ed-tech serves over 8 million students
from more than 500 K-12 schools to enhance student
performance. It needed a data platform to deliver real-
time insights by reducing ETL complexity and costs in
moving data from AWS RDS to Google BigQuery to scale
for 3 million users per month.
“MySQL HeatWave improved our complex query
performance 300X for responses in seconds and at 85% of
the cost compared to Google BigQuery with no code
changes. Now we can better deliver real-time analytics at
a scale of 3 million users and continually improve our
application to enhance student performance.”
Vitor Freitas
CTO, Estuda.com
Results::
300X faster performance from migrating from
BigQuery to HeatWave MySQL with no code
changes and low-latency
85% cost reduction by eliminating ETL processes
and pay-for-use consumption model
Real-time analytics enable faster development to
improve app usability and adoption
Scales queries to any data size for more flexibility
growth to impact more students
Read story

ML_TRAIN: To train the model on a training dataset
ML_MODEL_LOAD: To ensure the model used is loaded to Heatwave ML
ML_PREDICT_ROW: To generate prediction on 1 or more rows of unlabeled data in JSON
ML_PREDICT_TABLE: To generate prediction for entire table of unlabeled data and save output to table
ML_EXPLAIN_ROW: To explain prediction for 1 or more rows of unlabeled data in JSON
ML_EXPLAIN_TABLE: To explain prediction for entire table of unlabeled data and save output to table
ML_SCORE: To check validity and quality of the existing model
ML_MODEL_UNLOAD: To unload a model used from Heatwave ML
MySQL HeatWave ML using SQL

Example using AWS services vs HeatWave
Using ML can also be complex
• ML is not built-in Redshift, need to export data to another ML cloud service
• It creates additional complexity, costs, and delays
• Not automated. Data science expertise is needed
Transactional database
(RDS for MySQL)
Analytics
database
(Redshift)
Object storage Machine learning
(Sagemaker)
Object storage
for ETL process
(S3)
ETL/Data
transformation
(Glue)
Data in object storage
Data in database
• ML is built-in: faster insights and no extra costs
• No need to be an ML expert, the ML lifecycle is automated
• Easily train ML models using data in database and object storage: better
outcomes
AWS Redshift
Oracle HeatWave

HeatWave AutoML automates the ML pipeline - delivers predictions and explanations
It’s easy for analysts without ML expertise to build ML models
Dataset
Data preprocessing
Algorithm selection
Adaptive sampling
Feature selection
Hyper-parameter tuning
Tuned model
Model explainer
Prediction explainer
• Predictions
• Explanations
• Helps with regulatory compliance,
fairness, repeatability, causality, and trust
• Example: Explain to a customer why a
loan or credit card was refused

• Provides personalized suggestions based on user activities,
e.g. movie/product recommendations, ads…etc
• Considers both implicit feedback (past purchases, browsing
behavior…) and explicit feedback (ratings, likes…)
• Predicts
• Items a user will like
• Users who will like an item
• Ratings an item will receive
• Similar users
• Similar items
• RedShift ML and Snowflake do not provide recommender
systems
Recommender system in HeatWave AutoML
Browsing
behavior
Likes
Ratings
Written
reviews
Purchases
Feedback
loop
Fully automated process
Rec. sys
Preprocessor
Algorithm
Selection
Model
Tuning
Identify top k
algorithms
Hyperparameter
tuning
Optimized
Model
Imputation
Transformers

Text processing with HeatWave AutoML
Fintech
Media
Dig Mkt
Education
Services
Support
HeatWave AutoML
Tabular
columns
Text
columns
AutoML
Engine
Tabular
Processor
Language
Processor
(TfIdf/BERT)
Numerical
representation
Embeddings
Tuned
Model
Classification
Regression
Forecasting
Identify anomalies
Recommendation
• Relevance of words in documents
• Understand the context of words in a sentence
Enables users to perform machine learning tasks on text columns

Teyuto boosts customer
experiences with recommendation
engines built on HeatWave MySQL
Business challenge:
Teyuto is an Italian SaaS ISV that develops applications for people who want to
create branded white-label video platforms. It initially adopted MySQL
Community Edition on AWS and later on Google Cloud. However, Teyuto
wasn’t satisfied with the performance and the complexity of needing to
integrate and manage different services for transactions, analytics, and
machine learning. The startup needed a cost-effective, high-performance
machine learning engine to power its Teti AI recommendation system.
Products:
HeatWave MySQL and HeatWave AutoML
“For me, HeatWave is the future because of its
machine learning integrated within
MySQL with immense power. It’s astounding
and the speed is remarkable. HeatWave
AutoML has it all.”
Marcello Violini
CEO & Founder, Teyuto S.r.l.
Results:
With HeatWave AutoML, increased satisfaction by enabling subscribers to
keep their customers engaged and willing to purchase more products and
services via personal recommendations
Built-in analytics give subscribers real-time statistics of the number of
viewers per channel or individual video, revenue, demographics, and more
Gained 50% more staff productivity by redeploying resources previously
engaged in programming as HeatWave provides a fully integrated OLTP,
OLAP, and ML system
Saved 35% in operational costs
Eliminated complex ETL processes
Read full story here

MySQL HeatWave GenAI
Embedded LLM, Vector DB, RAG

86%
of IT leaders expect generative AI to
soon play a prominent role in their
organizations
250%
year-over-year growth for generative
AI projects on GitHub in 2025
95%
of developers are using generative AI
tools to write new code for software
applications
Generative AI is reshaping our world
Sources:
https://www.forbes.com/sites/bernardmarr/2025/01/29/10-mind-blowing-generative-ai-stats-everyone-should-know-about/?sh=7795815e1bdb;
https://www.iotworldtoday.com/connectivity/generative-ai-projects-more-than-triple-on-github-in-2025;
https://bloggingwizard.com/generative-ai-statistics/
• Embedding model selection
• LLM selection
• Meaningfully apply LLMs, embeddings to domain
problems
• Performance optimization
AI expertise
• External LLM integration
• Separate vector database
• Vector embedding generation
• Difficult to implement natural language capability
Complexity
• Hiring AI experts
• Provisioning GPUs
• Storing vector embeddings
• Optimizing system resources
High costs
Implementation challenges

MySQL HeatWave GenAI: Integrated and automated Generative AI
No AI expertise required, no data movement, and no additional cost
In-database LLMs
• Quickly benefit from GenAI anywhere without
integration hassle
• Help reduce infrastructure costs
• Use external LLMs via integration with OCI
Generative AI
Scale-out vector processing
• In-memory, scale-out architecture
• Perform fast semantic searches
• 15X faster than Databricks, 18X faster than
Google BigQuery, and 30X faster than
Snowflake.
Automated, in-database vector store
• Use GenAI with your business data without
moving data to a separate vector database
• Automate vector embedding generation without
AI expertise
• Combine GenAI with in-database ML
HeatWave Chat
• Engage in natural language conversations
informed by unstructured documents
• Ask follow-up questions; chat context preserved
• Guide LLMs to retrieve information from specific
data sets to help increase speed and accuracy

MySQL HeatWave GenAI enables new use cases and apps
Content generation and
summarization
• Generate insights/reports
from enterprise
documents
• Generate blogs from PDF
instruction manuals
• Summarize content
RAG and similarity
search
• Use GenAI with your
organization’s data
(Retrieval Augmented
Generation)
to get more accurate and
contextually relevant
answers
• Perform similarity searches
Synergy of integrated
GenAI and ML
• Save time and deliver
more value to customers
by combining ML and
GenAI
• Help reduce costs and get
more accurate results
faster by using GenAI on
data filtered by AutoML
Conversations in natural
language
• Conversations informed
by your unstructured
documents using natural
language
• HeatWave Chat preserves
context for follow-up
questions
+

Also integrated with OCI Generative AI service
In-database LLMs and in-database embedding generation
Applications
HeatWave
Object store
Pretrained
models
In-database
LLM
Natural language
question
Natural language
response
Augmented
prompt
Vector Store
HeatWave Chat
Embedding
Generation
HeatWave
AutoML

Building GenAI applications with most databases is complex
Discover
user
documents
Parse data
from
documents
Extract
metadata
Split data
into
segments
Choose
embedding
model
Create vector
embeddings
Design
vector store
Insert
metadata +
segments +
embeddings
into vector
store
Ensure
consistency of
ML model
when querying
Part 1 - Create a vector store
Part 2 – Use the vector store with LLMs
Ask a
Question
Choose
embedding
model
Create
query
embedding
Select
Vector store
to search
Select search
algorithm
Select search
results
Create
prompt with
search
results and
guard rails
Select LLM Get Results
Complex, slow and expensive

Only one step with HeatWave
Discover
user
documents
Parse data
from
documents
Extract
metadata
Split data
into
segments
Choose
embedding
model
Create vector
embeddings
Design
vector store
Insert
metadata +
segments +
embeddings
into vector
store
Ensure
consistency of
ML model
when querying
Part 1 - Create a vector store
Part 2 – Use the vector store with LLMs
Ask a
Question
Choose
embedding
model
Create
query
embedding
Select
Vector store
to search
Select search
algorithm
Select search
results
Create
prompt with
search
results and
guard rails
Select LLM Get Results
Simple, fast and cheap
SQL> call sys.heatwave_load(schema_name, @source_location)
SQL> sys.ML_RAG("What is HeatWave?", @NL_response, @optional_search_params)

Enables new search capabilities for unstructured data
Enables semantic search
Brings generative capabilities of LLMs
to enterprise content
Improved
context LLM
Vector store
q
Natural
language
Nobel-prize winning
scientists like Marie
Curie, Max Planck,…
…Wilhelm Rontgen,
who won the inaugural
Nobel Prize in Physics
in 1901…
Esteemed
scientists
from the turn
of the century
Document 1
Document 2

All system resources are optimized by HeatWave
All the steps for vector store creation are completed inside
HeatWave Storage
Customer Bucket HeatWave Cluster
Vector Store tables
OIT
Parser
OIT
Parser
OIT
Parser
Encoder
Distribute
across cluster
Segmenter
Segmenter
Segmenter
Encoder
Encoder
Faster than generating a vector store at the application layer
document_name segment embedding
a.doc Hello World [1.0, 2.0, ..]
a.doc Program [0.5, 3.5, ..]
b.pdf Quick brown .. [1.0, 2.0, ..]
document_name segment embedding
hola.pdf Hola Mundo [1.1, 2.4, ..]
sol.html
marrón
rápido ...
[1.1, 2.6, ..]
días.doc
Juego en
marcha
[0.8, 3.1, ..]

Scales to 512 nodes
Similarity search done at near-memory bandwidth
HeatWave Storage HeatWave Cluster
Distance
(SIMD)
Distance
(SIMD)
Distance
(SIMD)
Distribute
across cluster
Local topK
Local topK
Local topK
TopK
embeddings
[1.0, 2.0, ..]
[0.5, 3.5, ..]
[0.5, 3.5, ..]
[1.0, 2.0, ..]
[0.5, 3.5, ..]
Vector table
Documents can be in different languages

Summarization
Content generation

Identifying a potentially problematic clause in contracts
Similarity search

Accessing internal policy documents to get fast answers
Retrieval Augmented Generation (RAG)

Personalized recommendations
RAG enhanced with ML

Predictive maintenance
Analysis Generation

HeatWave Chat
Chat
Lakehouse Navigator
Global and refined search
Interact with your documents using natural
language. Context is preserved to enable
conversations with follow-up questions.
Guide LLMs to retrieve information from
specific datasets across the database,
HeatWave Lakehouse, and HeatWave Vector
Store to increase speed and accuracy.
Query all the vector stores or limit the scope of
the search to a particular schema.

Rapid HeatWave GenAI adoption across industry segments
Big data and
cloud
engineering
Semiconductor
and technology
manufacturing
Hospitality
Online
food delivery
Big Data and AI
Online learning
IT security
Management
Data platform
as-a-service
Telecom

Similarity search
HeatWave GenAI is 15X-30X faster and less expensive
Total
time
(sec)
Cost/hour
($)
0
100
200
300
400
500
HeatWave Snowflake Databricks BigQuery
30x
15x
18x
0
2
4
6
8
10
12
HeatWave Snowflake Databricks BigQuery
Cost/hour
($)
Cost
1.3x
2.6x
6.4x
https://www.oracle.com/heatwave/performance-benchmarks/#heatwave-genai

Vector store of 223 million segments, 6.8million HTML docs created in 1.7 hours (~35K segment/sec)
In-HeatWave vector store creation scales out
HeatWave
Nodes
Number of
Segments 18 M 38 M
7 M 13 M
0
10,000
20,000
30,000
Segments
/
second
5
10
20
512

Vector Store: retrieval augmented generation and SQL queries
LLM
Improved context
Vector Store
⨝
SQL
Tables
Query
Results
RAG

Integration with AutoML improved performance, lowers costs
AutoML + GenAI GenAI only
The error message indicates that the Spark
application is running into an OutOfMemoryError
while trying to allocate memory for a task. This can
happen if the amount of memory allocated to the
task is not sufficient or if there are other processes
running on the machine that are consuming too
much memory. ….
USEFUL RCA
A Spark RDD (Resilient Distributed Dataset) is an
immutable, distributed collection of data that can
be partitioned across multiple nodes in a cluster. It
is designed to handle large datasets that do not fit
into memory and provides fault-tolerance by
replicating data across multiple nodes. ….
IRRELEVANT RCA
3.6 minutes 6 hours
~200 ~30,000
Reduces cost: The input prompt size can be reduced
Improves performance: Helps reduce the size of the
input prompt to the LLM
Improves accuracy: Sharing only relevant context in
input prompt with the LLM
Vector Store
Generative AI
Predict relevant context
AutoML
HeatWave
GenAI +
HeatWave
AutoML
Enables new
applications: Explain
anomalies, generate
content from
recommendations

Chat context maintained in the server for applications to use
MySQL HeatWave provides support for chat capabilities

MySQL HeatWave GenAI
Quick Demo

HeatWave Demo
https://youtu.be/K5U2OusN3-8?si=Sf0ThDlVaVpnZU8T

“HeatWave in-database LLMs, in-database vector store,
scale-out in-memory vector processing, and HeatWave
Chat are very differentiated capabilities from Oracle that
democratize generative AI and make it very simple,
secure, and inexpensive to use. Using HeatWave and
AutoML for our enterprise needs has already
transformed our business in several ways, and the
introduction of this innovation from Oracle will likely
spur growth of a new class of applications where
customers are looking for ways to leverage generative AI
on their enterprise content.”
Eric Aguilar
Founder, Aiwifi
“We believe that Generative AI can enhance the
efficiency of our client-facing teams through use
of semantic search and summarization of documents
by using HeatWave GenAI with the HeatWave Vector
Store which offers unique capabilities. We are working
on this potential use case and we hope to productize the
benefits to our teams."
Ramesh Lakshminarayanan
CIO & Group Head-IT, HDFC Bank

“HeatWave GenAI makes it extremely simple to take
advantage of generative AI. The support for in-
database LLMs and in-database vector creation leads
to significant reduction in application complexity,
predictable inference latency, and most of all no
additional cost to us to use the LLMs or create the
embeddings. This is truly the democratization of
generative AI and we believe it will result in building
richer applications with HeatWave GenAI, and
significant gains in productivity for our customers.”
Vijay Sundhar
CEO, SMARTERD
“We heavily use the in-database HeatWave AutoML for
making various recommendations to our customers.
HeatWave's support for in-database LLMs and in-
database vector store is differentiated and the ability
to integrate generative AI with AutoML provides
further differentiation for HeatWave in the industry,
enabling us to offer new kinds of capabilities to our
customers. The synergy with AutoML also improves
the performance and quality of the LLM results.”
Safarath Shafi
CEO, Eat Easy

“The integration of Generative AI in HeatWave is a major
leap forward for us at SOCOBOX. By bringing in-
database LLMs, automated vector processing, AutoML,
and Lakehouse into our workflows, we can now deliver
powerful AI-driven insights and applications without
the overhead of external tools. This comprehensive
approach not only simplifies our operations but also
ensures real-time, cost-effective solutions that
resonate with the demands of our customers.”
Hans Ospina
CTO & Founder
“HeatWave has been instrumental in our strategy to
leverage GenAI and Machine Learning capabilities.
AutoML for predictive analytics on data, in-database
LLMs, in-database Vector Store, and RAG within
HeatWave have been a cornerstone to easily secure the
adoption of Generative Artificial Intelligence with our
enterprise data—making it simpler and faster than other
solutions by combining all the capabilities into a
single data platform service. We look forward to
improving Toks customer experience, powered by
HeatWave GenAI, Lakehouse and AutoML.”
David Leo
GRG/Toks IT Director

Aiwifi migrates from Amazon RDS to
HeatWave MySQL on AWS
“With HeatWave MySQL’s incredible performance
and built-in machine learning, we knocked down
previous barriers to growth. Aiwifi estimates that
HeatWave MySQL replaced up to 5 external
systems. Making HeatWave available on multiple
cloud platforms is a very smart move by Oracle.”
Eric Aguilar, CEO & CTO, Aiwifi
Challenge:
Aiwifi is a Mexican company developing Wi-Fi solutions that connect
shoppers to websites through customized captive portals. Its value
proposition is to gather valuable customer data by tracking user profiles
and activity. Upon starting up in 2019, Aiwifi chose AWS as its platform
and Amazon RDS as the backend database. However, as the business
rapidly grew and generated heavy data loads, the lack of performance
became a bottleneck for sustained growth, and database costs became a
heavy challenge. In 2025, it migrated from Amazon RDS to MySQL
HeatWave running natively inside AWS.
Products Used:
MySQL HeatWave
Results:
Queries ran 13X faster and loading time on captive portals dropped by 50%,
allowing Aiwifi to quickly onboard new customers without added costs
Costs were reduced by 50%. The MySQL HeatWave high performance
allowed using a smaller instance and high data egress fees were eliminated
MySQL HeatWave efficiently handles complex queries on more than 40
million records to provide real-time analytics dashboards
The need for query optimization was eliminated, allowing Aiwifi’s developers
to focus on building machine learning models with HeatWave AutoML
ML is used to segment their user base and create more personalized
marketing content as well as to predict offers that could be of interest to
different customer segments
Read the full story

REST Service
End-to-end Use Case
Configure REST Endpoints
via VSCode / SQL
Managed by
Customer
HeatWave Compute Instance
Mobile Apps
(Swift, Java, Kotlin)
PWA
(TypeScript, JavaScript)
Load
Balancer
Web Apps
E-commerce
IOT
(sensor data)
Node 1 Node 2 Node N
HeatWave Cluster
Procedure
Endpoints
MySQL Router
+ MRS Plugin
Function
Endpoints
View
Endpoints
Static- &
Script Files
JavaScript
Stored
Procedure
Views
Tables
MySQL REST Service
metadata
No Middle
Tier
Needed
Managed by
Oracle
Public REST Access
Customer manages
his own NLB (free) /
Load Balancer
Internal REST Access
via Customer VCN
Customer
VCN
MySQL Server
JSON/Rel
Duality
Views
WF Agent MACS Agent

64 ECPUs
32 ECPUs
16 ECPUs
8 ECPUs
4 ECPUs
2 ECPUs
MySQL HeatWave REST Service - Performance
16 ECPUs
Memory
Cached
16 ECPU
No Cache
faster performance
on same shape
2x
Up to
93k
requests/s with
only 64 ECPUs
Memory Caching
for
2x
faster performance
on smaller shapes
Database Object primary lookup on sakila.actor Table with ETag
calculation on standard OCI Compute Instance with 8 OCPUs
Database Object primary lookup on sakila.actor Table
running on standard OCI mysql.16 shape

MySQL HeatWave REST Service - Performance
HeatWave
REST Service
nginx
Web Server
Apache
Web Server
faster than
Apache
2x
Static files
served with speeds
comparable to
nginx web server
Dynamic
REST endpoints
served with
competitive speeds
HeatWave REST Service
Python + FastAPI + Uvicorn
NodeJS + Fastify + PM2
Java + Spring
16 concurrent clients matching
the VM’s 8 OCPUs/16 threads
Static file being served from VM.Standard.E4.Flex
OCI Compute Instance with 64 OCPU, 339 GB ram
Primary Key lookup on sakila.actor Table with ETag
calculation on OCI Compute Instance with 8 OCPUs

MySQL REST Service - Building Blocks
1. RESTful Web Services
• Auto REST for tables, views and routines
• {JSON} responses with paged results
• Developer support (GUI, CLI, API)
• Support for popular OAuth2 services
MySQL REST Service
Fast, Secure HTTPS Access for
MySQL Data & Apps
2. REST SQL Extension
sql> CONFIGURE REST METADATA;
sql> CREATE REST SERVICE /myService;
sql> CREATE REST SCHEMA /sakila
ON SERVICE /myService FROM `sakila`;
• Fully manageable through REST SQL extension
• Full GUI support for increased ease-of-use
3. Powerful Data Mapping
• Nested TABLEs to REST endpoints mapping
• Visual Data Mapping Editor to build complex
JSON structures with ease
• SQL & SDK Preview
4. Client SDK Generation
• Tailored SDK for all RESTful Endpoints
• Fully-typed SDK to prevent errors
• Popular, Prisma-like API, live prototyping

• Powerful WYSIWYG Data-Mapping Editor
• Creation of complex JSON structures with a few clicks
• Automatic database schema analysis
• REST SQL Preview
1 Add single relational table as REST object
2 Click referenced table to add nested JSON documents
3 Store REST Mapping
MySQL Shell for VS Code – MRS Support

MySQL HeatWave
Migration Strategy

Migration program overview
• Proven end-to-end approach
• Step-by-step best practices guides
• Free expert guidance
• Free technical training resources
• Assistance available from partners
How to migrate to MySQL HeatWave?
oracle.com/mysql/migration

Migrate to HeatWave MySQL with confidence in 4 easy steps
Proven end-to-end approach

Migration planning questionnaire
Step-by-step best practices guides
Key questions intended to help you assess your migration readiness and
start planning your migration project.
Business considerations
Scope of application considered, approval of key stakeholders,
timeline...etc
Technical considerations
• Source architecture: database version, size, replication used...
• Business continuity requirements: RTO and RPO requirements,
downtime allowed for migration?
• Backups: Schedule, retention period, storage...
• Migration to HeatWave MySQL on OCI? AWS?

10 available guides
• MySQL on-premises to HeatWave MySQL on OCI
• MySQL on-premises to HeatWave MySQL on OCI (live migration)
• MySQL on-premises to HeatWave MySQL on AWS
• Amazon RDS for MySQL to HeatWave MySQL on OCI
• Amazon RDS for MySQL to HeatWave MySQL on OCI (live migration)
• Amazon RDS for MySQL to HeatWave MySQL on AWS
• Amazon Aurora to HeatWave MySQL on OCI
• Amazon Aurora to HeatWave MySQL on OCI (live migration)
• Amazon Aurora to HeatWave MySQL on AWS
• MariaDB to HeatWave MySQL on OCI
Step-by-step best practices migration guides
Other resources are available to migrate from other sources.

Simply follow the detailed instructions
Step-by-step best practices migration guides

The popular and free MySQL Shell
Only one migration tool needed

Now supports migration of various sources to MySQL HeatWave on OCI
Alternative option: OCI Database Migration
How it works
Sources and target

Free expert guidance
https://go.oracle.com/LP=132857
Receive one-on-
one virtual
guidance from a
Solution Engineer
for your specific
project

Industry analysts about HeatWave
“This enables organizations to eliminate the complexity and cost of integrating separate analytics and
vector databases and trying to maintain data consistency, as well as separate lakehouse and ML services
in their application architecture, not to mention the time-consuming ETL processes to move data around all
those services.”
—Carl Olofson, Research Vice President, Data Management Software
"HeatWave represents the fiscally responsible approach to cloud databases while AWS Redshift and
Snowflake represent the fiscally reckless approach.”
—Ron Westfall, Senior Analyst and Research Director, Futurum
“HeatWave demonstrates that Lakehouse performance can be identical to transaction query
performance—unheard of and even unthinkable.”
—Holger Mueller, VP and Principal Analyst
“With in-database LLMs that are ready to go and a fully automated vector store that’s ready for vector
processing on day one, HeatWave GenAI takes AI simplicity—and price performance—to a level that its
competitors such as Snowflake, Google BigQuery and Databricks can’t remotely begin to approach.
—Steve McDowell, Principal Analyst & Founding Partner
Source: https://www.oracle.com/mysql/heatwave/analysts/

READ
Website Blog
Technical Briefs
HeatWave GenAI AutoML
Lakehouse Autopilot
User Guide Reference Architecture
WATCH
Intro in 5 minutes
Video Channels
Oracle Developer MySQL
Webinars
English Italian
RUN
LiveLabs
Free 30 Days Trial
Always Free Tier
Oracle University
LEARNING

Oracle MySQL HeatWave - Complete - Version 3

Oracle MySQL HeatWave - Complete - Version 3

More Related Content

Similar to Oracle MySQL HeatWave - Complete - Version 3

More from Luca Bonesini

Recently uploaded

Oracle MySQL HeatWave - Complete - Version 3