Skip to main content

v26.1

This article describes the release notes for VeloDB Core v26.1.

Note VeloDB Core v26.1 was developed based on Apache Doris v4.1.

v26.1.1 (July 9, 2026)​

This is the first release in the v26.1 series. It is based on Apache Doris v4.1 (build base 4.1.2-rc01), includes the fixes delivered through v26.0.4, and adds VeloDB-specific enhancements. The v26.1 series brings the full Apache Doris 4.1 feature set, so this note describes the 4.1 capabilities as they are exposed in VeloDB Core.

New Features

  • Added the search() function, which runs full-text search directly in SQL with an Elasticsearch query_string-compatible DSL. It supports the TERM, PHRASE, WILDCARD, REGEXP, PREFIX, and NESTED operators, BM25 relevance scoring through the score() column, multi-field search, and searching inside Variant JSON arrays without flattening them first.
  • Added the IVF approximate nearest neighbor vector index ("index_type"="ivf") as a lower-memory alternative to HNSW for large-scale vector search, together with an on-disk variant ("index_type"="ivf_on_disk") for vector sets whose indexes are larger than available memory.
  • Added vector index quantization, including INT8 scalar, INT4 scalar, and product quantization, which reduces vector index memory by roughly 4 to 8 times at a small cost in recall.
  • Added DOC mode for Variant columns, which keeps the whole JSON document as written and postpones splitting it into per-field storage until compaction. This lowers the cost of writing wide JSON documents in small batches.
  • Added the V3 storage format ("storage_format"="V3") for ultra-wide tables. It stores column metadata separately instead of packing it all at the end of each file, so tables that have tens of thousands of columns or many Variant subcolumns open faster and perform better on random reads and point queries.
  • Added native storage of very large JSON documents, up to roughly 100 MB each, in Variant columns. Long documents such as full conversation histories, agent execution traces, and RAG context can be stored and queried directly, without splitting them across rows or external files.
  • Added Condition Cache, which caches the result of a filter condition on a segment of data and reuses it when the same filter runs again over unchanged data, so repeated queries with the same filter run faster.
  • Added recursive common table expressions through WITH RECURSIVE for hierarchical and graph-style queries.
  • Added UNNEST syntax for expanding arrays and other nested values into rows.
  • Added the standard SQL MERGE INTO statement for performing insert, update, and delete against a table in a single statement.
  • Added the json_each and json_each_text table functions for expanding JSON objects into key-value rows.
  • Added the array_cross_product function for calculating the Cartesian product of multiple arrays.
  • Added the murmur_hash3_128 scalar function, the exponential_moving_average aggregate function, and DataSketches HLL aggregate functions.
  • Added current_database as an alias for the existing database() function.
  • Added full read and write support for Iceberg V2 and V3 tables, including row-level UPDATE, DELETE, and MERGE INTO, together with reads of Iceberg V3 deletion vectors and row lineage.
  • Added Iceberg JDBC catalogs, sorted writes, static partition overwrite, and the publish_changes procedure.
  • Added Paimon JDBC catalogs and SQL operations for creating and dropping Paimon databases and tables.
  • Added CREATE TABLE, DROP TABLE, and INSERT INTO support for MaxCompute external catalogs.
  • Added a Parquet metadata table-valued function for inspecting row groups, column statistics, and other file metadata through SQL.
  • Added INSERT INTO support for file table-valued functions, allowing query results to be exported to HDFS or S3.
  • Added the cdc_stream table-valued function for reading MySQL and PostgreSQL change streams and using them as Streaming Job sources.
  • Added AWS MSK IAM authentication for Kafka Routine Load jobs.

Improvements

  • Improved complex join and aggregation queries with aggregation pushdown through joins, which pre-aggregates each join input before the join to reduce the number of rows, the memory used, and the latency.
  • Improved queries that compute several groupings at once (such as GROUPING SETS, ROLLUP, and CUBE) by computing the most detailed grouping first and deriving the coarser ones from it, which reduces the work done.
  • Improved queries that read a single field inside a nested column (such as a field of a STRUCT) so that only that field is read from storage, for both internal tables and ORC and Parquet external tables.
  • Improved queries that contain CASE WHEN through branch merging, branch elimination, and common subexpression extraction.
  • Added Query Cache, which caches the intermediate aggregation result of a query and reuses it when the same aggregation runs again over unchanged data.
  • Improved execution across common operators and functions, including smarter join order and data shuffle selection and faster LIKE, FROM_UNIXTIME, and COUNT, which lowers overall query memory use and latency.
  • Enhanced spill to disk for large joins, aggregations, and sorts. The hash join, aggregation, and sort operators can now spill intermediate data to local disk in multiple levels when memory runs low, so memory-intensive queries finish on limited memory instead of failing.
  • Improved large table scan throughput and memory efficiency by sizing scan batches adaptively.
  • Improved vector search performance by letting an approximate nearest neighbor query read only the vector index, avoiding reads of the original vector column.
  • Improved repeated Parquet queries by reusing decompressed data pages, added an Iceberg manifest cache that avoids repeatedly parsing the same manifest files during query planning, and improved Paimon query performance through a native reader.
  • Sped up ORDER BY ... LIMIT queries on indexed columns by reading the full row data only for the rows that end up in the result, and improved explode and posexplode execution.
  • Improved storage of very wide JSON documents in which most keys are queried rarely. Those infrequently used keys are now spread across several internal columns and their reads are cached, which reduces read amplification and latency spikes.
  • Added multi-stream updates for the primary key table model, so different data streams can each update different columns of the same table and merge by their own sequence column.
  • Extended Routine Load with flexible partial column update, dynamic tuning through ALTER ROUTINE LOAD, and adaptive batch sizing based on backlog.
  • Added adaptive MemTable flush scheduling, which matches write concurrency to the current cluster load in high-write scenarios.
  • Extended MySQL and PostgreSQL CDC Streaming Jobs with custom table mapping, snapshot-only synchronization, PostgreSQL schema-change handling, excluded columns, and additional PostgreSQL data types.
  • Added explicit starting offsets, compute-group selection, structured failure reasons, and per-job lag and progress metrics for Streaming Jobs.
  • Improved full-snapshot CDC reliability for large or data-skewed tables by preventing tasks that are still making progress from being timed out and retried.
  • Changed window_funnel to use the more memory-efficient v2 implementation by default, while preserving the previous implementation as window_funnel_v1. In FIXED mode, rows that match no funnel condition no longer break the sequence, so affected queries may return a longer funnel chain after upgrade.
  • Extended multiple aggregate and array functions to accept TIMESTAMPTZ values, and extended max_by and min_by to support complex types.
  • Added unified runtime statistics and progress reporting for running queries, so you can see how far a query has progressed.
  • Added the compute group to MTMV refresh task output so refresh placement can be inspected directly.
  • Improved elastic scaling in the storage and compute separation architecture, so adding or removing compute completes faster and balance scheduling no longer depends on the total number of tablets.
  • Added the information_schema.file_cache_info system table, which reports file cache usage by tablet, backend, and cache path so you can investigate hot data and uneven cache distribution.
  • Added Stream Load records to the audit log, so import history can be queried and audited alongside other statements.
  • Reduced storage footprint and improved cold-read performance through better column encoding and compression, including moving the default compression toward ZSTD.
  • Reduced memory pressure during row-store ingestion and when parsing sparse Variant documents.
  • Added a default limit of 768 buckets per partition. CREATE TABLE and ADD PARTITION now reject partitions that exceed this limit.

Bug Fixes

  • Fixed date and time constant folding disagreeing with runtime execution for *_diff functions that use nullable literals or cross year 0000, for datediff on zero dates, and for convert_tz across daylight-saving transitions.
  • Fixed coalesce returning NULL when a nullable floating-point argument contained an unused NaN value and a later argument supplied the expected non-NULL result.
  • Fixed incorrect results when runtime filters were pushed through the nullable side of an outer join.
  • Fixed query plans reusing pre-aggregation state across separate join branches, which could produce an incorrect plan when the branches required different aggregation behavior.
  • Fixed queries against a SELECT * view over an external table failing with an IndexOutOfBoundsException after columns were added to the source table and its metadata was refreshed.
  • Fixed tokenize returning only one row when its first argument was constant and the query scanned multiple input rows.
  • Fixed json_contains treating numerically equal JSON values such as 1 and 1.0 as different, and fixed duplicate array candidates causing incorrect containment results.
  • Fixed enable_insert_strict silently changing cast behavior for INSERT statements. Insert row filtering and enable_strict_cast now operate independently.
  • Fixed COM_RESET_CONNECTION clearing the selected database and leaving other session state partially reset, which could break pooled MySQL connections after a reset.
  • Fixed queries failing with an invalid-precision error when reading legacy DecimalV2 data that was written by Doris versions earlier than 2.1.0.
  • Fixed MATCH rejecting aliased Variant dot subcolumns such as msg.trace_id, and fixed nested Variant searches binding to the wrong inverted index.
  • Fixed array subscripts and element_at returning NULL when applied to a Variant subpath that the optimizer had pruned.
  • Fixed sparse Variant paths inferring the wrong element type for mixed-type arrays and losing TIMESTAMPTZ values during serialization.
  • Fixed background compaction failing on Variant columns that hold arrays of nested JSON objects when a row's nested value was NULL or empty.
  • Fixed low or zero recall for IVF and PQ vector indexes when training used only part of a segment, and fixed ANN range-search state leaking between segments. Segments with insufficient training rows now skip index creation instead of failing the write.
  • Fixed window_funnel v2 returning an incorrect longest chain in DEDUPLICATION and FIXED modes when a later starting event produced a longer valid sequence.
  • Fixed an MTMV skipping required refresh work after excluded_trigger_tables changed, and fixed partitioned MTMV checks failing when the caller supplied an immutable excluded-table set.
  • Fixed PostgreSQL CDC jobs with multiple tables and offset=initial permanently losing changes during the snapshot phase, and fixed same-named tables in matching schemas causing a Duplicate key failure.
  • Fixed cdc_stream offsets not surviving an FE checkpoint, which could make a resumed job continue from the wrong source position.
  • Fixed Stream Load failing with a broken pipe during redirected requests whose body had not been consumed, and fixed backend selection failing when backend ID differences exceeded the integer range.
  • Fixed JSON ingestion mapping STRUCT subfields by position instead of by name when the input field order differed from the table schema.
  • Fixed workload-group queries being resumed while their memory reservation was still unavailable, which could bypass the intended pause behavior.
  • Fixed client queries hanging until socket timeout when an FE master switch caused the final result packet to be lost.
  • Fixed transactional INSERT INTO ... VALUES failing with a null pointer in multi-compute-group deployments when a backend from another compute group was selected.
  • Fixed a failed ADD PARTITION leaving stale partition metadata when rollback started after part of the catalog update had completed.
  • Fixed vertical compaction exhausting memory on large rowsets because available buffer capacity was calculated incorrectly.
  • Fixed migrated Iceberg tables without explicit write-format properties being read with the wrong file format, and fixed Iceberg writes ignoring a configured object-store.path data location.
  • Fixed incorrect COUNT DISTINCT results on Iceberg V3 row-lineage tables and fixed position-delete files being written without required Iceberg field IDs.
  • Fixed Iceberg writes failing when partition values contained characters that require URL encoding, and fixed large sorted Iceberg writes failing after spilling intermediate data.
  • Fixed SQL Server JDBC catalogs omitting built-in schemas from SHOW DATABASES when used with newer Microsoft JDBC drivers.
  • Fixed Paimon JDBC system-table queries failing with No suitable driver found when the query ran through the native Paimon scan path.