Glonce

TidesDB ships TideSQL, a storage engine plugin for MySQL 9.7 and 26.7

infrastructureThe Glonce editorsHacker News🔥40Glonce rating40Impact40Novelty45Relevance80Surprise20Players10Credibility75
TidesDB ships TideSQL, a storage engine plugin for MySQL 9.7 and 26.7

On October 5th, 2026 the TidesDB project announced that its storage engine is now available for MySQL as an external plugin called TideSQL. TidesDB is described as a write and space optimized storage engine library that keeps up well on reads through a hybrid LSM architecture. TideSQL started life as a MySQL fork, because at the time the MySQL community offered no way to build a plugin. After almost a year, a proposal for TidesDB to become available for MySQL was created, and the plugin route is now possible.

TideSQL is a plugin, not a fork: you run a stock MySQL and load the engine into it, and a TidesDB table can sit next to an InnoDB table in the same server. TideSQL v2.0.0 is paired with TidesDB v10.1.1 and tested against MySQL server v9.7.0 and v26.7.0. For now it is installed through the install.sh script in the plugin repository, which can either point at your own build or build the bundle for you. The author says easier access is wanted and that discussions with the appropriate parties are under way.

Configuration works through ENGINE_ATTRIBUTE, a JSON object on CREATE TABLE, because MySQL has no engine-specific table grammar. The engine validates the option names, so a misspelled option fails the statement. Every option has a tidesdb_default_* session variable behind it. Compression is on by default, with NONE, SNAPPY, LZ4, ZSTD and LZ4_FAST available and LZ4 as the default.

Large values are kept out of compaction. Each SSTable has its own key log, and the whole database shares one segmented value log. A value at or above tidesdb_value_separation_threshold goes to the value log, leaving a logical id in the key log, so a merge carries the pointer rather than the value. The cost is one value-log read per row on a scan, so a table scanned far more than it is merged can set {"keep_values_inline": true}. The LSM shape can be tuned per table with level_size_ratio, min_levels and l1_file_count_trigger. There is no compaction policy to choose: the engine picks among preemptive merge, dividing merge and partitioned merge based on the state of the tree. For delete-heavy tables, tombstone_density_trigger escalates compaction for SSTables whose tombstones outgrow a set ratio.

Durability is one setting, tidesdb_memtable_sync_mode, covering every commit because all tables share the library's write-ahead log. FULL (the default) means a committed write has reached the device and survives power loss. INTERVAL hands each commit to the operating system and reaches the device within the interval, so a process crash loses nothing and a machine crash loses at most that window. NONE does nothing at commit time, so an acknowledged commit sits in a buffer and a process crash loses it.

Other features listed: row expiry at table, row or session level; per-row encryption at rest with a two-tier key arrangement, so rotating the master key touches no row data (encrypted tables have compression forced off, while their secondary indexes keep the chosen algorithm); FULLTEXT indexes with natural-language and boolean modes and BM25 ranking; foreign keys enforced inside the engine with CASCADE, SET NULL and RESTRICT; spatial indexes, generated columns and JSON; instant ADD COLUMN and DROP COLUMN; optimizer statistics sampled without ANALYZE TABLE; online backup and checkpoints; and SHOW ENGINE TIDESDB STATUS. Vector columns can be stored and read back, but there is no similarity search over them.

Concurrency is optimistic MVCC with no pessimistic row locks, so there are no lock waits or lock-wait deadlocks. A write conflict appears at commit as ER_ERROR_DURING_COMMIT (1180), and applications using explicit BEGIN ... COMMIT at REPEATABLE READ or higher should retry on it. Autocommit statements run at READ COMMITTED, where the library does no write-write checking, and a transaction that wrote nothing never conflicts.

The benchmarks are the author's own. Sysbench 1.0.20 ran against both engines on the same server, with 8 tables of 5 million rows and each engine on its own defaults. The only changes from stock were READ COMMITTED and the durability mode, matched across both engines. The box was an Intel i9-13900 (24 threads online, 8 P-cores and 16 E-cores, with the 8 P-cores isolated for the run), 125.5 GiB of DDR5, and a Micron 7450 NVMe drive with xfs. Throughput is charted at 24 threads, where the box peaked, and bytes written to the device per operation were measured from /proc/diskstats, not from either engine's accounting, with a settling period after each run. The article text gives no actual transactions-per-second or bytes-per-operation figures; they are in charts.

The author explains the gap this way. The roughly 8 GB dataset is far larger than TideSQL's shipped 256 MB block cache and 256 MB memtable and InnoDB's 128 MB buffer pool, so neither engine holds it in memory. An InnoDB update of a random row must find a 16 KB page that is usually not resident, read it, change it and write all 16 KB back through the doublewrite buffer with redo on top. TidesDB appends a few hundred bytes and sorts it out later.

Standard sysbench rows are about 188 bytes, and values only go to the value log at 1024 bytes or more, so none of those workloads exercise it. A separate test used 4 tables of 200,000 rows with a 4 KB text column built to compress like log lines or JSON. It compared InnoDB, TidesDB by default (value separation) and TidesDB with keep_values_inline as a control, so the value log is the only variable. Inline TidesDB and InnoDB landed on the same insert number, and value separation was three times both. The author concludes the gain on large writes comes not from being an LSM but from compaction rewriting the keys and leaving the values in place.

On read latency, inline had the fastest median at 0.07 ms but an average of 0.38 ms and a worst case over 40 ms, because compaction hauls the values around under the reads. The default averaged 0.09 ms with a 6 ms worst case. The same 3.05 GiB payload took 4.24 GiB on InnoDB and 1.19 GiB on TidesDB (LZ4 at defaults, on text-like data). Loading took InnoDB 17 seconds against 8 for TidesDB. Raw data and scripts are offered as a download.

Key facts

  • TideSQL v2.0.0 (with TidesDB v10.1.1) is a plugin, not a fork: it loads into stock MySQL, tested on v9.7.0 and v26.7.0, and TidesDB tables can sit beside InnoDB tables.
  • Installation is currently through the install.sh script in the plugin repository; easier access is hoped for, with discussions ongoing.
  • In the author's 4 KB-value test (4 tables of 200,000 rows), value separation gave three times the insert throughput of both inline TidesDB and InnoDB.
  • The same 3.05 GiB payload took 4.24 GiB on InnoDB and 1.19 GiB on TidesDB with default LZ4; loading took 17 seconds on InnoDB against 8 on TidesDB.
  • Concurrency is optimistic MVCC: write conflicts surface at commit as error 1180, and vector columns are stored but cannot be searched by similarity.

Why it matters

MySQL users get an LSM-based engine they can load into a stock server instead of a fork, and mix it with InnoDB tables in the same instance. The project says the plugin route was impossible a year ago and has now opened up. The pitch is lower write amplification and smaller storage, with large values handled by a shared value log so compaction rewrites keys rather than values.

Who it affects

Teams running MySQL 9.x or 26.x with write-heavy tables, or tables with large values such as log lines or JSON documents, where disk writes and space are the cost. It also touches anyone who relies on pessimistic row locks, since TideSQL uses optimistic MVCC and surfaces conflicts at commit.

How to use it

Install through the install.sh script in the plugin repository, pointing it at your own build or letting it build the bundle. Then create tables with the engine and pass its options in ENGINE_ATTRIBUTE, or set tidesdb_default_* session variables once. Choose a compression algorithm (LZ4 is the default) and a durability mode through tidesdb_memtable_sync_mode (FULL by default). Tables scanned far more than merged can set keep_values_inline. Applications using explicit transactions at REPEATABLE READ or higher should retry on error 1180.

How solid is it

The claims and benchmarks come from the TidesDB project's own announcement, and the author is not named. The sysbench setup is described in detail (one machine, matched settings, writes measured from /proc/diskstats, raw data and scripts offered), and a control configuration was added to isolate the value log. But the article text gives no actual transactions-per-second or bytes-per-operation figures, since those are in charts, and no independent reproduction is mentioned.

Risks and caveats

Benchmarks ran on a single machine by the author, and standard sysbench rows never touch the value log. The compression result holds for text-like compressible data with LZ4 at defaults. Durability depends on the sync mode: NONE loses an acknowledged commit on a process crash, and INTERVAL can lose a window on a machine crash. Autocommit statements run at READ COMMITTED with no write-write checking. Vector similarity search is not supported, and installation is for now a script rather than a packaged route.

“TideSQL, which utilizes the library, is a plugin and not a fork.”

— TidesDB announcement, October 5th, 2026