Version information

• Release date: May 25, 2026

• Version: V1.3.0

• RPM package: seekdb-1.3.0.0-100000092026051510

Overview

seekdb V1.3.0 is a major release for multi-platform coverage and high performance. It introduces async indexes backed by a new Change Stream incremental framework that decouples writes from index builds, delivering extreme ingest throughput and stable retrieval for AI Agent workloads. Windows and Android native build and deployment extend platform coverage. Diff & Merge now supports vector columns, and Fork Table / Fork Database are fully aligned with async indexes for stronger multi-version data management.

New features

Async indexes

Async indexes offer a new vector index maintenance model. Unlike synchronous indexes, async indexes decouple DML from index construction: DML lands synchronously on the primary table (with MVCC and unique-index checks), while a background Change Stream pipeline consumes the CLOG and maintains the vector index asynchronously. Queries use the async index for similarity search, combining extreme ingest performance with predictable retrieval.

Change Stream incremental framework:

• Fetcher: Single-threaded CLOG consumer; assembles and orders changes per transaction, emitting deltas in commit order.
• Dispatcher: Slices transaction work, hashes by rowkey, builds execution context, and enqueues tasks for workers.
• Worker: Multiple threads run subtasks in parallel; all changes for the same rowkey are serialized on one worker—parallel execution with per-key ordering.

The framework is plugin-oriented: this release wires in HNSW; future releases can extend to full-text, JSON indexes, binlog-style consumers, and more—evolving seekdb from a storage engine into a real-time incremental compute engine.

Product behavior

When creating an HNSW vector index, set sync_mode:

• immediate — synchronous refresh, strong consistency.
• async (default) — automatic background refresh, eventual consistency.

-- Async vector index
CREATE TABLE t1(c1 INT, c2 VECTOR(3), c3 VARCHAR(256),
PRIMARY KEY(c1),
VECTOR INDEX idx1(c2) WITH (distance=l2, type=hnsw, lib=vsag,
sync_mode=async))
ORGANIZATION HEAP;

-- INSERT: rows land on the primary table; the index catches up asynchronously
INSERT INTO t1 VALUES(1, '[1.0, 2.0, 3.0]', 'seekdb 1.3');

-- Approximate search via the async index
SELECT c1, c3 FROM t1
ORDER BY l2_distance(c2, '[1.0, 2.0, 3.0]') APPROXIMATE LIMIT 5;

-- Manual refresh so recent commits become searchable
CALL dbms_index_manager.refresh();

Benchmarks (mixed read/write vector workload)

Streaming query performance under sustained insert pressure, measured with VectorDBBench. All runs use single-node deployment (16 vCPU / 64 GiB, Alibaba Cloud ecs.g8i.4xlarge). HNSW parameters: m=16, ef_construction=256, ef_search=200. Metrics captured at 80% of target data volume.

On the 10M mixed workload, async indexes reach 1,523 concurrent query QPS (about 22× sync mode) with concurrent P99 latency of only 21.7 ms.

Windows build and deployment (experimental)

seekdb can be built, deployed, and run natively on 64-bit Windows (x86_64). An MSI installer and Configurator wizard support one-click install, service management, and password configuration. Named Pipe transport handles the MySQL protocol for local development and production on Windows.

Highlights:

• MSI: Standard Windows install flow with a configurable install directory.
• Configurator: Can launch after install to set data directory, ports, passwords, and related options.
• Named Pipe: MySQL protocol over Windows named pipes.
• VSAG: Full VSAG vector index support on Windows.

Limitations:

• Currently supported on Windows 11 64-bit (x86_64) only.

Android build and deployment (experimental)

seekdb can be built and run on Android, including standalone APK packaging for embedded mobile-style database scenarios.

Highlights:

• Android NDK build with gRPC and SQLite dependencies integrated.
• Standalone APK output.
• Platform-specific syscall and datatype behavior handled where needed.

Improvements

Async index retrieval performance

Deep optimizations on the async index retrieval path: skip unnecessary reads of internal table 4 during HNSW search to cut I/O; improved log recycling and timeouts so background maintenance interferes less with foreground queries.

Vector Diff & Merge

Diff & Merge (introduced in V1.2.0) now supports vector columns: forked copies can be compared with DIFF and merged with MERGE for stronger multi-version vector workflows.

Fork Table / Fork Database with async indexes

Fork Table and Fork Database are fully aligned with async indexes. Fork correctly handles tables with async indexes; targets keep async index state consistent with the source and can refresh and query indexes independently after fork.

Standby read performance

Improved read performance on standby nodes, reducing query latency in primary–standby deployments.

Resource usage

Streamlined background timers and removed redundant modules: about 30% fewer idle threads and about 40% lower CPU usage on small, idle instances.

Bug fixes

Vector index

• Fixed follower memory usage when loading vector indexes. (6345e2a9)
• Fixed hangs during vector index DDL. (4ee3c5cd)
• Fixed error 4016 during semantic index refresh when model_name was empty. (8b07ab1c)
• Fixed sparse_vector count handling. (53d70df5)
• Fixed a crash on Windows from an uninitialized discrete vector pointer. (24ea18b8)

Fork Table / Fork Database

• Fixed forked index tables incorrectly using columnar layout. (fec0210d)
• Fixed a deadlock while taking a snapshot during Database Fork. (0d4fbab4)
• Fork Table now rejects columnar source tables. (21168b47)
• Narrowed Fork unlock dependent-task checks to the correct scope. (b6e5047a)
• Fixed lost fork_info on standby fork targets during migration updates, which could hang queries. (204685d5)

Primary and standby

• Fixed a deadlock replaying DDL_TABLE_FORK_START_LOG on a standby. (0caeb70d)

macOS

• Fixed PL exception-handler encoding compatibility (DW_EH_PE_signed / DW_EH_PE_indirect) on macOS ARM64. (81fd8751)
• Fixed a crash in sort comparators on error paths on macOS. (5aa611c0)

Other

• Hardened handling when physical_plan_ctx / sql_ctx is null in materialized-view paths. (3627a343)
• Fixed unsafe comparison helpers. (c66ebaea)
• Fixed RPC communication errors. (0f85e9bf)
• Fixed a crash in spi_parse_prepare when triggers referenced dropped columns. (dd7a0906)
• Fixed a SIGSEGV in embedded mode. (18fbabda)
• Fixed snap payload deserialization. (80ddc477)
• Fixed invalid data_table_id in rebuild-index tasks. (b1282f5f)
• Fixed advance-scan behavior. (6006e21f)
• DDL-related hardening patch. (e686da62)

Upgrade notes

• In-place upgrade from V1.0.x, V1.1.0, or V1.2.0 to V1.3.0 is not supported. Use a logical migration with OBDUMPER/OBLOADER or mysqldump.

For step-by-step instructions, see Upgrade seekdb with mysqldump.

Related components

Version information

• Release date: March 25, 2026

• Version: V1.2.0

• RPM package: seekdb-1.2.0.0-100000232026041319

Overview

seekdb V1.2.0 is a major milestone that takes seekdb from a single-node database toward a high-availability architecture. This release delivers primary–standby replication for stronger disaster recovery, Fork Database for whole-database versioning, and Diff & Merge syntax for Git-style branch comparison and merging. Under the hood, internal refactoring plus vector and full-text optimizations make the database more dependable and faster for enterprise workloads.

New features

Primary and standby databases

seekdb's first high-availability offering is asynchronous primary–standby replication in maximum-performance mode. Replication uses gRPC for RPC. You can copy baseline data at any time and stream incremental logs afterward. If the primary becomes unavailable (planned or not), the standby can take over with lossless switchover or lossy failover, cutting downtime and addressing single-point-of-failure risk while meeting enterprise expectations for data safety and DR.

Highlights:

• Asynchronous standby provisioning: Add a standby at any time without stopping the primary.
• Near real-time log sync: The standby pulls incremental logs from the primary over the network.
• Lossless switchover: Used when the primary (upstream) is still reachable; verifies log completeness before cutover.
• Lossy failover: Used when the primary is gone; enables emergency takeover.
• Switchover verify: Validates switchover commands and runs checks only. No data or role changes are applied.
• Cascading standbys: Supports chains such as primary → standby 1 → standby 2.
• Loosely coupled topology: Standbys know the primary; the primary does not track standbys. One primary, multiple standbys.

Limitations:

• Standby reads: Standbys are read-only; schema and replication lag can make reads slightly behind the primary.
• Vector reads on standby: Not fully supported yet; will improve in a future release.
• Reads after standby restart: Sync positions are not fully persisted; reads may appear to "go backward" after a restart.
• Applications after switchover/failover: Connection strings must be updated to point at the new primary.

Fork Database

V1.1.0 added Fork Table: fast, size-independent copies for AI coding, knowledge bases, A/B tests, and other multi-version workflows. V1.2.0 extends that with Fork Database: at a snapshot time chosen by the system, seekdb creates a target database that matches the source's logical state at that moment. All user tables and rows are included. The fork is a normal database you can read and write. Use it when you need whole-database versioning, not just single tables.

Highlights:

• Single snapshot across the database: All tables in the fork share one fork snapshot, so joins and foreign keys stay logically consistent after the fork.
• Inherited database settings: The target inherits charset, collation, and other database-level properties from the source.
• Empty databases: You can fork a source with no user tables; the result is an empty target.
• Multiple forks: Fork the same source to different targets as often as needed; each fork uses its own snapshot and is independent.
• Foreign keys: Table-level foreign keys inside the source database are preserved and enforced in the target. Cross-database foreign keys are omitted during fork and are not created in the target.

Limitations:

• Objects not forked: Procedures, functions, triggers, sequences, and statistics metadata are not included in Fork Database.

Table Diff & Merge

Diff & Merge brings Git-like workflows to data: branch, diff, and merge. The three pillars are Fork (copy data), DIFF (compare), and MERGE (merge by policy). Typical uses include validating AI-generated changes before production, isolating parallel development branches, reconciling experiment outputs, and iterating on model training data. Compared with ad hoc scripts, changes become observable and controllable, making them safer, auditable, and easier to collaborate on.

Improvements

DDL sampling with incremental data

Before V1.2.0, building vector or full-text indexes after bulk loads could skew because DDL sampling ignored incremental data, causing uneven parallel builds and long tail latency. V1.2.0 improves sampling (including row-based and hybrid sampling) so estimates track real data better, parallel work splits more evenly, and index builds finish faster.

Vector index concurrent writes

Coarse read/write locking on HNSW indexes is removed so DML can run concurrently, improving throughput (QPS).

Full-text search performance

Top-K and incremental-data paths are optimized via a lightweight advance_scan in the storage layer, tuned BM25 parameters, and better algorithms for incremental queries. In tests, pure incremental workloads saw up to about 80% faster Top-K queries; mixed workloads also improved noticeably.

System architecture

The kernel drops unused multi-tenant and distributed code paths, simplifying the codebase, lowering overhead, and easing operations.

Bug fixes

Vector index

• Fixed error -4016 when dropping an index. (c9cb3c49)
• Ensured need_res_cnt in vector queries respects FIXED_MAGNIFICATION_RATIO_EACH_ITERATIVE. (1d6444cc)
• Corrected complete-data handling on the brute-force search path. (853efa1a)
• Resolved a hang when dropping an index after offline DDL failure. (0122f92b)
• Fixed offline DDL failures when rebuilding IVF indexes and hangs during vector index drop. (71a4c616)
• Fixed HNSW scan iterator and memory cleanup on error paths in create_vec_hnsw_lookup_tree. (b5e98215)
• Fixed set_force_partition behavior. (7d14e905)

Full-text search

• Full-text build jobs no longer stall after a hidden internal table is removed. (42c0d191)
• Fixed concurrency issues when loading the IK tokenizer dictionary. (b5d96efa)

macOS

• Build fixes on macOS. (c227b311)
• Trigger error handling on macOS. (6fdedbcc)
• PL/SQL exception handlers now catch errors correctly on macOS ARM64. (215df8fd)
• Fixed current_time() uint64 underflow that could cause query timeouts on macOS. (33e0c3de)
• Resolved ambiguous max() calls in ob_partition_range_spliter.cpp. (ffff1640)

Other

• Fixed -4016 during tablet deletion. (738cdd55)
• Fixed DML remove-locker behavior. (4cb9dde6)
• Fixed non-convergence in a conversion path. (dcf7be66)
• gather_schema_stats no longer incorrectly skips OB_NOT_SUPPORTED. (b47d6460)

Upgrade notes

• In-place upgrade from V1.0.x or V1.1.0 to V1.2.0 is not supported. Use a logical migration with OBDUMPER/OBLOADER or mysqldump.

For step-by-step instructions, see Upgrade seekdb with mysqldump.

Related components

Version information

• Release date: January 30, 2026

• Version: V1.1.0

• RPM version: seekdb-1.1.0.0-100000142026013001

New features

macOS build support

As of V1.1.0, seekdb supports native builds and local development on macOS 15 and later.

FORK TABLE (experimental)

V1.1.0 introduces FORK TABLE, which lets you create a copy of a table without a full data copy. Unlike CTAS (Create Table As Select), FORK TABLE reuses table-level storage and uses copy-on-write so that creation time and resource use stay low regardless of data size, while preserving consistent semantics.

Tip:
In V1.1.0, FORK TABLE is experimental. Use it with caution and avoid relying on it in production until it is promoted to a stable feature in a later release.

Typical use cases:

• AI coding and safe test data: AI code assistants generate SQL, ORM code, and data APIs from table structure and sample data, and may need to change schema or data. FORK TABLE gives AI a dedicated copy of your data so it can learn and experiment on realistic structure and distribution; once changes are validated, you can apply them to the production table.

• Multi-version knowledge bases: When the live knowledge base is serving users and you need to update many FAQ or document entries in the background, you may want to keep multiple versions until new content is validated. FORK TABLE lets you copy the live knowledge base quickly, update the forked table offline without affecting the online service, and then promote the new version (for example with RENAME TABLE) when ready.

• Shared and private knowledge: When multiple customers or business lines share a common AI knowledge base but need some content to be private or customized, you can fork from a single "master" table into multiple tables, add private documents and customizations per fork, and control access and release separately.

• A/B testing: Create multiple variants from the same production snapshot to compare different indexes, parameters, or SQL patterns without paying the cost of full copies.

• Offline DDL and change validation: For risky changes (column type changes, schema changes), fork the table first, run and validate the change on the fork, then apply to the original table to avoid unexpected impact on production.

• CI/CD validation: Add a FORK TABLE step to your pipeline so that before releasing code to production, you can run tests against a production-like snapshot without touching live data.

Syntax: FORK TABLE source_table TO destination_table;

Behavior: Creates destination_table from a snapshot of source_table. Both tables can be read and written independently. You can use DROP TABLE or RENAME TABLE to roll back or promote a version.

Performance: Fork typically completes in hundreds of milliseconds.

Storage optimizations

V1.1.0 lowers minimum resource requirements for data storage, CLOG storage, and system log storage so that seekdb is easier to run in resource-constrained environments.

• Data file allocation: seekdb pre-allocates data file space at startup. Under light load, actual usage can be on the order of tens of MB; a large default was wasting disk. In V1.1.0, the default data file size is reduced from 2 GB to 32 MB. The default auto-extend behavior is also changed: instead of a fixed 2 GB step, the system now uses an adaptive step. When the data file is under 1 GB, it doubles using the current file size as the step; once the file reaches 1 GB, the step is 1 GB. You can override this with the datafile_size and datafile_next configuration options.

• CLOG disk usage: Previously, CLOG was often configured with a 10 GB default (some deployment tools or container images used 2 GB), and that space was pre-allocated at startup, which was heavy for small environments. V1.1.0 changes the default CLOG disk size to half of memory_limit with a minimum of 2 GB, and improves allocation and reclaim so that checkpoint SCN advancement reclaims old log space and keeps CLOG usage low. For larger setups that need to retain more CLOG, you can tune log_disk_size and log_disk_utilization_threshold.

• System log disk usage: The default system log level is changed from WDIAG to WARN, and the default number of retained log files is reduced from 4 to 2, so less is written to disk and I/O is lower. seekdb supports seven log levels, from most to least verbose: DEBUG → TRACE → WDIAG → EDIAG → INFO → WARN → ERROR. DEBUG, TRACE, WDIAG, and EDIAG are diagnostic levels for development and troubleshooting; INFO, WARN, and ERROR are aimed at DBAs and operators for monitoring and incident response. The new default WARN reduces noise and storage. You can change the level with syslog_level and the number of retained files with max_syslog_file_count.

Memory management improvements

V1.1.0 refines memory management so that seekdb behaves well across different deployment sizes (small or large memory, standalone or co-located with other services).

• Dynamic memory usage: The memory_limit parameter caps how much memory seekdb uses. Under normal operation the process stays within this limit. During one-off high-memory phases (e.g., compaction, bulk load, large sorts), seekdb may temporarily exceed the limit if the system has free memory, which improves stability and throughput on smaller instances. For large datasets or higher performance, increase memory_limit as needed.

• Configurable hard memory limit: A new option memory_hard_limit sets a strict upper bound on seekdb memory. The default is 0, meaning 90% of system memory is used as the hard limit; you can set an explicit value. This prevents runaway allocation and is especially useful when seekdb runs alongside other components so that it does not starve them.

Configuration changes

Bug fixes

Vector index fixes

• Fixed timer-based scans in vector indexes that could cause high CPU usage (176a6e13)
• Fixed IVF similarity data loss (f443e5ac)
• ObPluginVectorIndexHelper now uses the hard memory limit (e9dd7c54)
• Expressions are now supported in DBMS_HYBRID_SEARCH.GET_SQL (ae256978)

Semantic index fixes

• Fixed semantic index creation failure and embedding failure on very long data (c9495bac)
• Fixed hybrid vector index LLM invocation errors (222f653f)

Other fixes

• Reduced IK parser load time (87ab54c3)
• Fixed direct load transaction state mismatch (a0511d92)
• Fixed st_intersects/st_covers performance issues (fc805e45)
• Fixed issues related to storage optimization (019838e0)
• Fixed auto-increment sequence lifecycle handling (94228ef3)
• Fixed compaction state abnormalities (27736694)
• Fixed DAG task error code being overwritten by ob cancel (8252547f)
• Added fsync before reading macro blocks during SSTable build (7f8bddf3)
• SQL memory tracker now uses the hard memory limit (a27dea95)
• Refactored I/O callback threads to use ObLinkQueueThreadPool (c42e5f71)

Upgrade notes

In-place upgrade from 1.0.x to 1.1.0 is not supported. To move to 1.1.0, use a logical migration with OBDUMPER/OBLOADER or mysqldump.

Related components

Version information

• Release date: December 29, 2025

• Version: V1.0.1

• RPM version: seekdb-1.0.1.0-100000392025122619

New features

Vector Index Enhancements

• HNSW-BQ distance metrics: Added support for IP (Inner Product) and cosine distance metrics for hnsw_bq index type. (7aecf39c)
• Vector search limit increase: Increased ef_search upper limit to 160,000. (79111e92)

Bug fixes

Vector Index Fixes

• Fixed bugs for multiget row get not equal issue in vector index (b955f8c1)
• Fixed expr core and empty data issue in vector index (b329ac7a)
• Fixed insert on duplicate key update for heap table with semantic index (19a672f3)
• Fixed select heap table with vector index when in list expr rewrite to subquery (628f2eee)
• Fixed add vector fail but insert bitmap is set when supplement data for incr hnsw (0d8355f2)
• Fixed sparse vector memory leak (93bcb851)
• Fixed insert_bitmap construct bug (1fc4f1d4)
• Fixed parse sparse vector core issue (aa5b651e)
• Fixed parallel dml error in vector index (2c6b6501)
• Fixed alter table drop index for hnsw heap table (32145b5c)
• Fixed vector index offline DDL hung when create failed (7262d305)
• Fixed hnsw insert on duplicate key update (666df298)
• Fixed IVF build helper memory not cleaned up (4792ef0b)

Semantic Index Fixes

• Fixed hybrid vector index refresh task returning error 4377 (5c18b3ce)
• Fixed hybrid vector index refresh error 4002 on heap table with subpartition (d85c6b98)
• Fixed hybrid refresh error 6005 (dcf78c58)
• Fixed hybrid task return 4016 caused by null pointer (cd0382c7)
• Fixed hybrid vector index refresh core at deconstruct embedding task (ea665790)
• Fixed hybrid vector index refresh task memory bloat (8664da62)
• Fixed hybrid vector index rebuild error 4016 (db7ced0c)
• Fixed hybrid vector manual execute rebuild hung issue (b55102ff)
• Fixed ai service guard memory leak in hybrid refresh task (2f10d62c)
• Fixed return 1210 for empty string in semantic_distance (aed0d544)
• Fixed insert on duplicate key update for heap table with semantic index (19a672f3)
• Fixed hybrid vector index refresh task return 5024 (d21c6971)
• Fixed hybrid refresh task return error 4016 (fa91585c)

Full-Text Search Fixes

• Fixed ignore index_back dimension for fulltext search query due to functional lookup (3e722c89)
• Fixed bm25 max score param skip index on mini/minor sstable (62b8aa62)
• Fixed disallow index merge plan when query has ES match (d469e190)
• Fixed 4016 error in ES match while index merge is set (e2ba5933)
• Fixed tokenization in AND operator (e4d1f12a)
• Fixed IK dictionary memory leak when loading with different names (e21d828f)

Other Fixes

• Fixed del_upd parallel dop calc bug (2fda21a0)
• Fixed pdml create index correct problem (9f3002e9)
• Fixed insert on duplicate key update error 5500 (02167423)
• Fixed system package mview refresh with SQL warning exception (8996cebf)
• Fixed inability to handle nested requests (e11f87ab)
• Fixed core due to wrong static type cast (a44b2526)
• Fixed ServerObjectPool memory leak (beeb04d0)
• Optimized reboot performance. (c8342b5f)
• Optimized timezone refresh to reduce CPU consumption. (7e1cb41e)

Upgrade notes

This release supports upgrading from version 1.0.0 to 1.0.1.

Version information

• Release date: November 14, 2025

• Version: V1.0.0

• RPM version: seekdb-1.0.0.0-100000262025111218

For more information, please see the seekdb v1.0.0 release notes.