SQLite vs MySQL

Quick verdict

SQLite is a C library that implements a self-contained SQL database engine. Its documentation describes it as serverless in the classic sense: the process that wants to use the database reads and writes the database file on disk directly, with no intermediary server process, and there is nothing to install or configure. The whole database is a single cross-platform file. SQLite is in the public domain. The latest release listed on sqlite.org is 3.53.4 (24 July 2026).

MySQL is a client-server relational database owned by Oracle. A mysqld server process manages the data, and applications connect to it over TCP/IP or a local socket with a user name and password. The default storage engine, InnoDB, is transactional and multi-versioned. MySQL Community Server is free under GPLv2, and Oracle sells commercial editions and the MySQL HeatWave cloud service. MySQL now uses calendar versioning: 26.7.0 is the current Innovation release, and 8.4 and 9.7 are the Long-Term Support lines offered on the download page.

Side by side

Key differences

Embedded versus client-server

SQLite runs inside your application's process. There is no network protocol, no port to open and no service to monitor; you ship the library (or use the one built into your platform) and open a file. The sqlite.org "Appropriate Uses" page lists embedded devices and IoT, application file formats, websites with low to medium traffic, data analysis, caches and teaching as good fits.

MySQL is a separate server. That adds work (installation, configuration, backups, security patches, user management) but lets many applications on many machines share the same data. The same SQLite page names data on a separate machine from the application as a case where a client/server database is the better choice.

Concurrency: single writer versus many

sqlite.org states that SQLite supports an unlimited number of simultaneous readers but only one writer at any instant per database file. Write-ahead logging (WAL), available since 3.7.0, lets readers and the writer proceed concurrently, though there is still only one writer at a time. WAL is persistent once set, and the documentation notes it does not work over a network filesystem because processes must share memory.

-- SQLite: switch a database to WAL mode (persists in the file)
PRAGMA journal_mode=WAL;

MySQL's InnoDB engine is multi-versioned: the reference manual describes consistent non-locking reads of earlier row versions and row-level locking, so many sessions can read and write at the same time. If your workload has many simultaneous writers, this is the main reason to choose a client-server engine.

Typing and schema changes

Ordinary SQLite tables use flexible typing: a declared column type sets an affinity, and SQLite converts values when it can do so losslessly but otherwise stores what it was given. For example, in an ordinary table a column declared INTEGER stores the string '123' as the integer 123, but stores 'xyz' as text. STRICT tables, added in 3.37.0, reject values of the wrong type and allow only INT, INTEGER, REAL, TEXT, BLOB and ANY. SQLite has no dedicated date or time type.

-- SQLite: opt in to strict typing
CREATE TABLE customers (
  id   INTEGER PRIMARY KEY,
  name TEXT NOT NULL
) STRICT;

SQLite's ALTER TABLE supports renaming tables and columns, adding and dropping columns and, from 3.53.0, setting or dropping NOT NULL. Changing a column's type or adding constraints needs the documented rebuild procedure (create a new table, copy, drop, rename). MySQL enforces declared column types and supports a wider range of ALTER TABLE changes, plus a native JSON type that is validated on insert. SQLite also has JSON functions, built in by default since 3.38.0.

SQL dialect differences

Auto-increment keys. In SQLite a column declared INTEGER PRIMARY KEY is an alias for the rowid and is filled automatically. The AUTOINCREMENT keyword only prevents reuse of deleted ids, and sqlite.org advises avoiding it unless strictly needed because of the extra overhead. MySQL uses AUTO_INCREMENT.

-- SQLite
CREATE TABLE orders (
  id    INTEGER PRIMARY KEY,
  total REAL
);
SELECT last_insert_rowid();

-- MySQL
CREATE TABLE orders (
  id    INT NOT NULL AUTO_INCREMENT,
  total DECIMAL(10,2),
  PRIMARY KEY (id)
);
SELECT LAST_INSERT_ID();

Upsert. SQLite has supported ON CONFLICT ... DO UPDATE since 3.24.0, using excluded for the incoming row. MySQL uses ON DUPLICATE KEY UPDATE; the manual marks the VALUES() function in this clause as deprecated and recommends a row alias instead.

-- SQLite
INSERT INTO phonebook (name, phone) VALUES ('Alice', '704-1212')
  ON CONFLICT(name) DO UPDATE SET phone = excluded.phone;

-- MySQL
INSERT INTO phonebook (name, phone) VALUES ('Alice', '704-1212') AS new
  ON DUPLICATE KEY UPDATE phone = new.phone;

Dates. SQLite stores dates as ISO-8601 text, Julian day numbers or Unix timestamps and works on them with functions such as date(), datetime(), strftime() and modifiers. MySQL has DATE, DATETIME and TIMESTAMP types and interval arithmetic.

-- SQLite: a week from today
SELECT date('now', '+7 days');

-- MySQL: a week from today
SELECT DATE_ADD(CURDATE(), INTERVAL 7 DAY);

Limits and scale

sqlite.org documents a theoretical maximum database size of about 281 TB (at the maximum 65,536-byte page size), a default maximum of 2,000 columns per table and a default maximum string or BLOB length of one billion bytes. Its own guidance is to choose SQLite for device-local storage with low writer concurrency and less than a terabyte of content. MySQL runs as a server that can use replication and, through NDB Cluster or Group Replication, multi-server configurations, so it is built for shared, networked workloads rather than a single file.

Pricing and licensing

SQLite is in the public domain: anyone may copy, modify, use, compile, sell or distribute it for any purpose, commercial or not. For organisations that need a formal document (for example where public domain is not recognised), Hwaci, the company that employs the SQLite developers, sells a Warranty of Title; sqlite.org does not list a price on its copyright page.

MySQL Community Edition is free under GPLv2, with additional permissions described by Oracle. Oracle offers a commercial licence for embedding or bundling MySQL in another product without GPL obligations, and paid editions (MySQL Enterprise Edition, Standard Edition, Classic Edition, NDB Cluster CGE) plus the MySQL HeatWave cloud service. No prices are shown on the MySQL product or "How to Buy" pages in October 2026; Oracle directs buyers to the Oracle Store, its sales team or partners. Managed MySQL is also offered by cloud providers such as Amazon RDS, priced by each provider.

We describe licence terms only. If GPL obligations matter for software you distribute, take your own legal advice.

Pricing checked on the vendors' official pages on 7 October 2026. Prices change; confirm before buying.

Where each one leads

Limitations

When to choose each

When neither is right

• Advanced SQL features, extensibility and a permissive licence matter more than MySQL compatibility: look at PostgreSQL; see MySQL vs PostgreSQL.
• You want a MySQL-compatible server with a different governance and licence history: see MariaDB vs MySQL.
• Your data is document-shaped and changes structure often: see MongoDB vs PostgreSQL and SQL vs NoSQL.
• Heavy analytical queries over large datasets are a job for a column-oriented engine or data warehouse rather than either of these.

Final recommendation

Frequently asked questions

Sources

• SQLite: Appropriate uses
• SQLite: Serverless
• SQLite: Write-ahead logging
• SQLite: Implementation limits
• SQLite: STRICT tables
• SQLite: Autoincrement
• SQLite: UPSERT
• SQLite: Copyright (public domain)
• MySQL Reference Manual: INSERT ... ON DUPLICATE KEY UPDATE
• MySQL Reference Manual: InnoDB multi-versioning
• MySQL Reference Manual: Replication
• MySQL licensing (OEM and commercial)
• MySQL Community Server downloads

Checked October 2026.

How we research comparisons: our editorial method.