dolt/CHANGELOG and dolt Releases

All Versions

Latest Version

2.1.4

Avg Release Cycle

3 days

Latest Release

3 days ago

Changelog History

Page 1

v2.1.4 Changes
June 05, 2026
🔀 Merged PRs
dolt
- 11178: Mark dolt_diff_$TABLENAME to_commit and from_commit indexes as non-unique
  The dolt_diff_$TABLENAME system table marked its to_commit and from_commit indexes as unique. A single commit changes many rows, so each commit hash maps to many diff rows and these indexes are not unique.
  🛠 Fix #11159
- 11177: Bug fix: don't rebuild fulltext indexes unnecessarily
  ⚡️ When two sessions are making changes to a table with a fulltext index, the index was unnecessarily getting rebuilt, even when the indexed column wasn't changing in the updates. This change limits when the index is rebuilt to avoid unnecessary rebuilds.
Closed Issues
- 11159: dolt_diff_$TABLENAME: mark to_commit and from_commit indexes as non-unique
v2.1.3 Changes
June 05, 2026
🔀 Merged PRs
dolt
- 11176: go/store/{val,prolly/tree}: Implement ValueContext for the places where we need a Context.
  dolthub/driver directly consumes these values and has the abilityt to pass the correct Context instance.
- 11172: bug fix for race condition in acquiring auto increment locks
  🔒 The global auto increment tracker had a race condition in Next(). In interleaved mode (the default), a necessary table-level lock was not being taken, leading to a non-atomic get-increment-set race between two concurrent sessions. This was due to the lock mode being stored in the struct itself and only set during some code paths. The fix sets the lock mode value at startup.
  ✅ The new test reliably reproduced the race condition before this patch.
- 11170: fix: persist table comment on indexed table creation
  Separate PRIMARY KEY clause routes creation through CreateIndexedTable which never sets schema comment.
  - Thread comment through CreateIndexedTable
    🛠 Fix #11163
    Close #11175
- ✅ 11168: add test for ALTER TABLE comment on primary key table
  🛠 Fix #11164
- 👍 11155: support NOT VALID for foreign key and check constraints
  Depends on dolthub/vitess#471 and dolthub/go-mysql-server#3573
- 11149: Implement IndexNameGenerator interface
  Depends on: dolthub/go-mysql-server#3571
- 🔒 11110: go/go.mod: Bump fslock, adopt fallible fslock.New() and the requirement to Close() the *Lock instance.
- 11001: Store adaptive-encoded values in lexical order
  In Dolt, all adaptive-encoded values are stored in an arbitrary order according to their raw bytes.
  
  funccompareAdaptiveValue(l,rAdaptiveValue)int{returnbytes.Compare(l,r) }
This isn't a problem for Dolt, because keys on columns that will be adaptively encoded post 2.0 (TEXT, BLOB) all require a key prefix length, which is used by the secondary index to order the keys correctly.
🏗 But for Doltgres, it's possible to create indexes on TEXT and VARCHAR (no length) columns without a key prefix length. This means that adaptive-encoded values must be stored in a canonical order independent of whether the value is stored inline or out-of-band. Otherwise, various SQL engine optimizations, like removing the Sort operation on an index range scan, would not yield correct results in Doltgres. There are also many other known and unknown assumptions in Dolt and go-mysql-server that break if values in indexed columns are not stored in a consistent order. Additionally, enforcing a canonical order for such columns makes it possible to bring these enhancements to Dolt in the future (by relaxing MySQL's constraints on key lengths), or in new products we might build.
This PR sorts adaptive encoded values by adding a ValueStore param to the Compare() interface. It is unused except when comparing adaptive values.
🐎 The downside to this change is that we must perform 1 or 2 additional disk reads for each comparison of out-of-band values. This is a large performance penalty but is unavoidable, and should (we think) happen in a small minority of cases.

go-mysql-server
- 3579: make hashjoin compatible with doltgres
  doltgres has different equality expressions, which prevented hashjoins from getting considered during join planning.
- 3578: fix: retain table comment when primary key is a separate clause
  CREATE TABLE ... COMMENT='c' dropped the comment when PRIMARY KEY was given as a separate clause.
  - Add a comment parameter to IndexedTableCreator.CreateIndexedTable and thread it through the executor.
    Block #11170
- 3577: fix: return ok result schema for ALTER TABLE comment
  AlterTableComment yields an OkResult row but reported the table schema, so schema-driven renderers (i.e. Dolt) formatted the OkResult against the first column and failed.
  Block #11168
  🛠 Fix #11164
- 3575: decompose tuple inequalities
  This PR extends the tuple in filter decomposition logic to cover tuples in equallities and inequalities.
- 3574: Ensure SchemaObjectNameValidator is used when a table is renamed
- 👍 3573: support NOT VALID on foreign key and check constraints
  Depends on dolthub/vitess#471
- 3571: Add IndexNameGenerator interface
  🆕 New IndexNameGenerator interface allows databases to customize the logic that generates index names when they aren't explicitly specified.
- 3570: improvements to time to wire format
  Should use apd.Decimal.Append() and faster way to append time strings.
  Benchmarks: #11130 (comment)
- 3568: bug fix for non-found search paths
- 3563: Introduce SchemaObjectNameValidator interface
  👍 To support custom Postgresql logic for Doltgres, a new interface called RelationNameValidator is added.
vitess
- 471: add not valid on fkey and check constraints
- 0️⃣ 470: Expand the set of function call expressions that can be used as a column default value without requiring parentheses.
  👍 These forms are not valid MySQL but are accepted by MariaDB. We should also accept them in order to have better compatibility with schemas created for MariaDB.
Closed Issues
- 11163: CREATE TABLE ... COMMENT is dropped when PRIMARY KEY is a separate clause
- 11164: ALTER TABLE ... COMMENT errors with types.OkResult despite persisting change
- 11141: Git remote cache retains refs/dolt/data history across force-pushed flattened histories
v2.1.2 Changes
June 02, 2026
🔀 Merged PRs
dolt
- 11150: fix(git-remote-cache): ensure remote cache compaction and pruning occurs via new Teardown lifecycle method
  ➕ Adds a new Teardown lifecycle method to ChunkStore (plus DoltDB and DoltDatabaseProvider) for Git remotes. Teardown drives the expensive end-of-process cleanup — git gc and deletion of per-session UUID refs — that previously fired implicitly inside Close and was therefore lost when the provider-level cache was removed.
  Close remains the cheap, deferrable per-operation hook; for the shared Git remote NomsBlockStore it is suppressed by a thin shim so caller defers don't tear down the shared instance. Also readds a provider-layer cache (Git remotes only) so a DoltDB is opened once per remote URL per process and reused across operations. At engine shutdown, the provider calls Teardown once, which drains both caches, runs the GC + ref cleanup, then force-closes each shared store.
- 11148: Fix dolt status to report AUTO_INCREMENT value changes
  ⚡️ ALTER TABLE foo AUTO_CINREMENT = N updated the table but dolt status continued to report "nothing to commit".
  - HasChangesIgnoringColumnTags now compares GetAutoIncrementValue between from and to tables.
    🛠 Fix #11145
- 📄 11147: dump-docs: emit a description: field in the generated cli.md frontmatter
  📄 The dolt docs site (dolthub/docs-2) now reads description: from each page's frontmatter — it powers the per-entry summary in llms.txt (the agent-readable docs index) and is wired up for OG/Twitter cards.
  📄 cli.md is generated by dolt dump-docs, so any description: added by hand to the docs repo gets overwritten on the next regeneration. Baking it into the constant header so it survives every regen.
- 11146: dolt status doesn't require both --use-db and --branch
  ✅ There was a gap in testing for the status command when you specify only --use-db, but no --branch name. This resulted in getting the error "could not find current branch commit"
  🛠 Fixes: #11137
Closed Issues
- 11145: dolt status does not surface an auto_increment change
- 11137: status requires both --use-db and --branch arguments
- 👍 11142: Error: The current API does not support the selected model gpt-5.5
🐎 Performance

✅ | Read Tests | MySQL | Dolt | Multiple | | --- | --- | --- | --- | | covering_index_scan | 17.32 | 2.3 | 0.13 | | groupby_scan | 142.39 | 132.49 | 0.93 | | index_join | 3.49 | 1.93 | 0.55 | | index_join_scan | 4.25 | 1.34 | 0.32 | | index_scan | 350.33 | 211.6 | 0.6 | | oltp_point_select | 0.2 | 0.26 | 1.3 | | oltp_read_only | 3.82 | 5.09 | 1.33 | | select_random_points | 0.37 | 0.55 | 1.49 | | select_random_ranges | 0.39 | 0.64 | 1.64 | | table_scan | 350.33 | 204.11 | 0.58 | | types_table_scan | 759.88 | 458.96 | 0.6 | | reads_mean_multiplier | | | 0.86 |

✅ | Write Tests | MySQL | Dolt | Multiple | | --- | --- | --- | --- | ✂ | oltp_delete_insert | 8.43 | 6.32 | 0.75 | | oltp_insert | 4.18 | 3.19 | 0.76 | | oltp_read_write | 9.22 | 11.45 | 1.24 | ⚡️ | oltp_update_index | 4.41 | 3.36 | 0.76 | ⚡️ | oltp_update_non_index | 4.18 | 3.07 | 0.73 | | oltp_write_only | 5.28 | 6.32 | 1.2 | ✂ | types_delete_insert | 8.58 | 6.79 | 0.79 | | writes_mean_multiplier | | | 0.89 |

✅ | TPC-C TPS Tests | MySQL | Dolt | Multiple | | --- | --- | --- | --- | | tpcc-scale-factor-1 | 94.1 | 52.69 | 1.79 | | tpcc_tps_multiplier | | | 1.79 |

Overall Mean Multiple 1.18
v2.1.1 Changes
June 02, 2026
🔀 Merged PRs
dolt
- 11136: Populate dolt_workspace schema with current table schema when deltas are nil
  🛠 fixes #11127
- 11111: New ProviderFactory interface
  Introduces a new ProviderFactory interface that allows Doltgres to extend database behavior.
  Depends on: dolthub/go-mysql-server#3563
go-mysql-server
- 3563: Introduce SchemaObjectNameValidator interface
  👍 To support custom Postgresql logic for Doltgres, a new interface called RelationNameValidator is added.
- 3562: pass schema name when retreiving function
Closed Issues
- 11127: Deieting from dolt_workspace_TABLE fails (only) when no rows exist in it with missing column error
- 10727: dolt push fails with 'uncommitted changes' when remote has ignored tables in working set
- 11131: Dolt 2.0.8: adaptive out-of-line TEXT written via migration is unreadable — "invalid hash length: 19" on read (regression vs 2.0.4)
v2.1.0 Changes
May 31, 2026
🚀 This is a minor version release to correct a bug discovered with TEXT and BLOB columns. Certain ALTER TABLE statements run on columns created by a 1.x release could result in the data in that column becoming unreadable after the statement. Example:
```
-- In Dolt 1.xCREATETABLEt1(
  idINTPRIMARY KEY,
  bodyTEXT);-- insert data into table-- in Dolt 2.x:ALTERTABLEt1 MODIFY body LONGTEXT;
```
After this ALTER TABLE statement, the data in the body column becomes is inaccessible because of a mismatch in encoding between what's recorded in the schema and the table rows themselves. No data is lost or corrupted, but it becomes inaccessible to queries.

This bug impacted TEXT and BLOB types (and types in the same family, e.g. TINYTEXT). Only ALTER TABLE statements were impacted, and only if they used MODIFY COLUMN or DROP COLUMN.

👀 For more details, see this bug report:

#11131

🚀 Releases between 2.0 and this release should be considered unsafe to use for customers with data written by any 1.x release. If you are using a previous 2.x release with data written by a 1.x release, please update to this release before running any ALTER TABLE statements.

🔀 Merged PRs
dolt
- 11132: bug fix for adaptive encoding during ALTER TABLE
  ALTER TABLE statements that change a columns type to e.g. widen it from TEXT to LONGTEXT have a bug: if the column was created pre-2.0, the ALTER TABLE statement will use an adaptive encoding for the modified column without rewriting the table row data. This results in unreadable data.
  To fix this, we preserve the encoding for columns during ALTER TABLE operations.
- 11125: go/{store/nbs,dbfactory,env}: Add functionality to fast-fail fslock, instead of serially waiting 100ms per DB load, when we already have some ReadOnly databases in the MultiRepoEnv.
- 11109: pass schema name for function
  Depends on: dolthub/go-mysql-server#3562
go-mysql-server
- 3567: fix for division on decimals
  BenchmarkPlusHighScaleDecimals:
  
  before (decimal.Decimal) 2505679 460.8 ns/op after (apd.Decimal) 3746318 304.5 ns/op
BenchmarkMinusHighScaleDecimals:
```
before (decimal.Decimal) 2619691 449.0 ns/op
after (apd.Decimal) 3723363 312.1 ns/op
```
BenchmarkMultHighScaleDecimals:
```
before (decimal.Decimal) 2537882 454.6 ns/op
after (apd.Decimal) 3608662 321.3 ns/op
```
BenchmarkDivHighScaleDecimals:
```
before (decimal.Decimal) 793515 1414 ns/op
before fix (apd.Decimal) 367 3112350 ns/op
after fix (apd.Decimal) 946606 1246 ns/op
```
BenchmarkDivManyDecimals:
```
before (decimal.Decimal) 130582 7691 ns/op
before fix (apd.Decimal) 54 21534736 ns/op
after fix (apd.Decimal) 110416 9347 ns/op
```
- 3562: pass schema name when retreiving function
Closed Issues
- 0️⃣ 11098: Support MariaDB non-parenthesized function defaults on TEXT/BLOB/JSON columns (extends #7033)

v2.0.8 Changes

May 29, 2026

🔀 Merged PRs

dolt

11124: integration-tests/go-sql-server-driver: no_table_files_read_test.go: Add test cases for multi-database usage.
11119: Do not make dolt_diff table indexes on nil schemas
Calling MakeDiffTableIndex on a nil schema was causing a panic. This would happen if a table existed on one branch but not on the other.
11118: enforce foreign keys when DELETING through dolt_workspace_TABLE
⚡️ Workspace table deletes were previously using a simple tableWriter, which went around the FK checks we make during typical updates.
Depends On: dolthub/go-mysql-server#3566
🛠 Fixes: #11112
11117: go/store/nbs: Lazily load chunk journal database resources when constructing a NomsBlockStore.
Most Dolt commands currently construct a MultiRepoEnv and then call
into the SQL layer to perform the actual work. In turn, the SQL layer
has some logic which looks at the state of the loaded databases and
👀 sees whether the process has ended up loading some of them in ReadOnly
mode. If it has, then in some cases the Dolt process will attempt to
connect to a running dolt sql-server instead of doing the work
against the database files itself.
This PR makes is to that the application code paths which inspect
🚦 AccessMode == ReadOnly can get that signal and make the attempt to
reach out to the server before all of the database state has to be
🐎 loaded from disk. This greatly improves the performance of running
dolt CLI commands against a running dolt sql-server, from the same
directory as the server data-dir.
11101: go/store/nbs: Clean up some manifest access patterns.
✂ Removes unnecessary manifestManager and its global cache and in-process locks.
11100: handle extended types during prollyRange construction
benchmarks: dolthub/doltgresql#2758 (comment)
11085: add where predicate feature to index (partial index)

go-mysql-server

3567: fix for division on decimals
BenchmarkPlusHighScaleDecimals:

before (decimal.Decimal) 2505679 460.8 ns/op after (apd.Decimal) 3746318 304.5 ns/op

BenchmarkMinusHighScaleDecimals:

before (decimal.Decimal) 2619691 449.0 ns/op
after (apd.Decimal) 3723363 312.1 ns/op

BenchmarkMultHighScaleDecimals:

before (decimal.Decimal) 2537882 454.6 ns/op
after (apd.Decimal) 3608662 321.3 ns/op

BenchmarkDivHighScaleDecimals:

before (decimal.Decimal) 793515 1414 ns/op
before fix (apd.Decimal) 367 3112350 ns/op
after fix (apd.Decimal) 946606 1246 ns/op

BenchmarkDivManyDecimals:

before (decimal.Decimal) 130582 7691 ns/op
before fix (apd.Decimal) 54 21534736 ns/op
after fix (apd.Decimal) 110416 9347 ns/op

🏗 3566: analyzer: export BuildForeignKeyEditor for callers outside DML analysis
Refactors the internal FK-editor builder chain (getForeignKeyEditor, getForeignKeyReferences, getForeignKeyRefActions, cache.GetUpdater, getForeignKeyHandlerFromUpdateTarget) to take *Catalog instead of *Analyzer since only a.Catalog was ever used. Adds an exported BuildForeignKeyEditor entry point so integrators can wrap a writer in a ForeignKeyEditor when their write path doesn't go through the analyzer (e.g. dolt's workspace tables).
0️⃣ 3565: Allow unparenthesized function expressions in column defaults.
0️⃣ MariaDB allows the use of a function expression as a column default expressions without requiring it to be wrapped in parentheses. MySQL does not allow this.
0️⃣ In order to parse scripts created for MariaDB, we should also accept unwrapped function expressions as column defaults. However, in order to ensure that dumps created by Dolt are compatible with MySQL, we normalize these expressions by wrapping them in parentheses internally.
3561: fix(rowexec): dispose CachedResults child when closing hashLookupGeneratingIter (#3560) ## Summary hashLookupGeneratingIter.Close returned nil without closing the child iter chain or disposing the wrapped *plan.CachedResults node. Every executed hash join over a CachedResults subtree could therefore leak one entry into Analyzer.CachedResultsManager.cachedResultsCaches, freed only by process restart.
This PR makes Close:
1. Dispose the CachedResults child if present (releases the global Manager entry).
2. Propagate Close down the rest of the child iter chain.

🛠 Fix

func (h *hashLookupGeneratingIter) Close(c *sql.Context) error {- return nil+ if cr, ok := h.n.Child.(\*plan.CachedResults); ok {+ cr.Dispose(c)+ }+ return h.childIter.Close(c)}

Why

Full RCA, reproducer, and pprof evidence are in #3560. Headline numbers from the 3-minute, ~30 req/sec workload reported there (Dolt 2.0.6 sql-server vendoring this commit):

Metric	Vanilla Δ	Patched Δ	Improvement
RSS	+5069 MB	+44 MB	~115×
HeapAlloc (live)	+4.3 GB	+82 MB	~52×
HeapObjects (live)	+90 million	+1.5 million	~60×
`Mallocs - Frees` (net live)	+204 million	+4 million	~50×
🏗	Allocation rate is unchanged (~1.1B mallocs in 3 min both runs); the patched build services the same workload but `Frees` keeps up with `Mallocs`.

✅ Tests

✅ go test ./sql/rowexec/... passes locally with the patch applied.
✅ I did not include a unit-level regression test in this PR. In a minimal engine.Query → RowIterToRows test, TrackedRowIter.Close → done → disposeNode already walks the plan tree and disposes the CachedResults via sql.Dispose(ctx, node), so the leak doesn't reproduce that way; faithfully exercising the production path (Dolt sql-server, prepared statements via the MySQL wire protocol) needs significantly more harness scaffolding. Happy to add a test if maintainers can point me at the right entry point.
Closes #3560

3553: add partial index on WHERE predicate
3537: sql: opt-in SQL trace redaction ## Summary ➕ Adds an opt-in redaction layer for the SQL text and identifiers that get attached to OpenTelemetry span attributes — the planbuilder parse-span query attribute and the rowexec table/left/right/index attributes. When enabled via a new sql.Context option, identifiers and literal values are rewritten into stable, low-entropy tokens (n1, n2, ..., v1, v2, ...) that repeat across queries of the same shape so trace storage compresses well.
👉 Use case: multi-tenant SQL servers (Dolt is one, our own dsabstraction layer is another) where tracing data flows to shared long-term storage. Operators want privacy regulation compliance and tenant isolation without giving up trace visibility entirely.
0️⃣ Default off to preserve backward compatibility — existing trace consumers reading query, table, left, right, etc. verbatim see no change. Callers opt in with sql.WithTraceRedaction(true). ## How it works Two passes over the same SQL, deliberately combined:
1. Parse to AST , walk it to collect every TableIdent and ColIdent string. The grammar is the authority on which lexemes are identifiers — necessary because vitess treats hundreds of words (NAME, USER, DATA, STATUS, ...) as non-reserved keywords: the lexer emits a keyword token type for them, but real queries use them as bare column / table names.
2. Lex the SQL and emit token-by-token. Literal token types (STRING, INTEGRAL, FLOAT, HEX, HEXNUM, BIT_LITERAL) redact as values. ID tokens redact as identifiers. COMMENT tokens drop. VALUE_ARG / LIST_ARG pass through. Any other token (keyword, punctuation, multi-char operator) emits structurally — unless its val is in the identifier set from step 1, in which case it redacts as an identifier (this catches the non-reserved-keyword-as-column-name case).
  Coverage is bounded by the grammar's notion of identifier (TableIdent + ColIdent) and the lexer's fixed set of literal token types — not by an evolving list of AST node fields. Future grammar / AST shape changes are covered automatically as long as they go through Walk and produce the same lexer token classes.
  📜 This is deliberately distinct from sqlparser.Normalize / RedactSQLQuery, which is a plan-cache primitive that parameterizes literals only, dedupes only inside SELECT, and skips long values for CPU. The redactor here treats traces as a privacy boundary: every high-cardinality token is rewritten, always dedupes, drops comments, and falls back to <unparseable> on parse failure rather than risk a partial redaction.

Examples

Before: SELECT * FROM t WHERE c1 = 'could_be_sensitive'
After: SELECT * FROM `n1` WHERE `n2` = 'v1'

Before: SELECT u.name, u.email FROM users AS u
After: SELECT `n1` . `n2` , `n1` . `n3` FROM `n4` AS `n1`

name is a non-reserved keyword in the vitess grammar — lexed with a keyword token type, not ID. A pure lexer-driven redactor would leak it. The hybrid grammar+lex approach catches it.

Before: WITH x (renamed_col) AS (SELECT a FROM t) SELEC...

v2.0.7 Changes

May 26, 2026

🔀 Merged PRs

dolt

11097: go/go.mod: Bump fslock to pick up recent minor cleanup.

go-mysql-server

3561: fix(rowexec): dispose CachedResults child when closing hashLookupGeneratingIter (#3560) ## Summary hashLookupGeneratingIter.Close returned nil without closing the child iter chain or disposing the wrapped *plan.CachedResults node. Every executed hash join over a CachedResults subtree could therefore leak one entry into Analyzer.CachedResultsManager.cachedResultsCaches, freed only by process restart.
This PR makes Close:
1. Dispose the CachedResults child if present (releases the global Manager entry).
2. Propagate Close down the rest of the child iter chain.

🛠 Fix

func (h *hashLookupGeneratingIter) Close(c *sql.Context) error {- return nil+ if cr, ok := h.n.Child.(\*plan.CachedResults); ok {+ cr.Dispose(c)+ }+ return h.childIter.Close(c)}

Why

Full RCA, reproducer, and pprof evidence are in #3560. Headline numbers from the 3-minute, ~30 req/sec workload reported there (Dolt 2.0.6 sql-server vendoring this commit):

Metric	Vanilla Δ	Patched Δ	Improvement
RSS	+5069 MB	+44 MB	~115×
HeapAlloc (live)	+4.3 GB	+82 MB	~52×
HeapObjects (live)	+90 million	+1.5 million	~60×
`Mallocs - Frees` (net live)	+204 million	+4 million	~50×
🏗	Allocation rate is unchanged (~1.1B mallocs in 3 min both runs); the patched build services the same workload but `Frees` keeps up with `Mallocs`.

✅ Tests

3558: Unwrap wrapped strings before casting to string during RegexpReplace.Eval
🛠 Fixes #11095
👍 REGEXP_REPLACE queries on LONGTEXT type columns were panicking because we were casting values to strings without unwrapping them. Note that this doesn't happen with tables created in Dolt 2.0 due to the recent changes to adaptive encoding, but we still need to support tables before then.
📦 Also moved mockStringWrapper to a shared test util package so it can be used in various tests.

Closed Issues

3560: CachedResults / HashLookup chain leaks rows-cache for every hash join until process restart

v2.0.6 Changes
May 23, 2026
🔀 Merged PRs
dolt
- ⚡️ 11081: Update docs URLs from docs.dolthub.com to dolthub.com/docs
  ⚡️ Update references from docs.dolthub.com to dolthub.com/docs across READMEs and CLI help text.
- 11060: more cleanup for prollyWriteSession
  ⚡️ This PR moves logic for updating the branch state from prollyTableWriter to prollyWriteSession.
  ➕ Additionally, it completely removes the mutex "protecting" prollyWriteSession.workingSet because it is unnecessary; there's no way the same prollyWriteSession is accessed by multiple threads.
go-mysql-server
- 3558: Unwrap wrapped strings before casting to string during RegexpReplace.Eval
  🛠 Fixes #11095
  👍 REGEXP_REPLACE queries on LONGTEXT type columns were panicking because we were casting values to strings without unwrapping them. Note that this doesn't happen with tables created in Dolt 2.0 due to the recent changes to adaptive encoding, but we still need to support tables before then.
  📦 Also moved mockStringWrapper to a shared test util package so it can be used in various tests.
- 3557: Include CHAR and VARCHAR in IN expression optimization
  🏗 A few months ago, I added an optimization to avoid building expensive RangeTrees.
  dolthub/go-mysql-server#3330
  This expands that optimization to include CHAR and VARCHAR column types.
  BINARY, VARBINARY, JSON, GEOMETRY, etc. could be included as well with some more effort.
  Internally, these types are represented as []byte, while CHAR and VARCHAR are string, so they are not of type cmp.Ordered and need a different sorting/comparison function (binary.Compare).
  👀 Locally, this seems to give 8-10% improvement on select ... from ... in (<str1>, <str2>, ...) queries
- 3556: Fix CHAR_LENGTH and LIKE failing on the replacement character
  The replacement character (Unicode U+FFFD, shown when text gets garbled during encoding conversion) is a normal, valid character. But CHAR_LENGTH would error on it instead of counting it. The fix adds that size check, so the valid character (3 bytes) is accepted while genuinely broken input (1 byte) is still rejected.
  🛠 Fix #11088
- 3555: Lookup table when not specified in DROP INDEX statements
  📦 MySQL requires the owning table for an index be explicitly mentioned when dropping an index, but Postgres does not. This change looks up the owning table for an index when it is not specified. Because MySQL requires the table name to be specified, tests for this functionality are in the Doltgres package (PR dolthub/doltgresql#2747).
- 3552: Do not allow CASCADE and SET NULL foreign keys on columns that are referenced by STORED generated column expressions
  🛠 fixes #11065
  📄 According to the MySQL docs:
⚡️ > A foreign key constraint on the base column of a stored generated column cannot use CASCADE, SET NULL, or SET DEFAULT as ON UPDATE or ON DELETE referential actions.
0️⃣ > (This is actually not totally true because I was able to create a such foreign key constraint with a SET DEFAULT referential action in MySQL)
0️⃣ > This PR prevents adding such foreign key constraints (with the exception of SET DEFAULT) during CREATE TABLE and ALTER TABLE. Note that in MySQL, the error messages for creating a new table with an invalid foreign key and adding an invalid foreign key to an existing table are different (Cannot add foreign key constraint vs Cannot add foreign key on the base column of stored column.), but I've decided to use the same error message for both cases (Cannot add foreign key on the base column of a stored generated column.).
🏗 > CreateTable.CreateForeignKeys was removed and replaced with BaseBuilder.buildCreateTableForeignKeys to avoid a cyclical import.
- 3550: modify CompareJSON to use sorted object keys
- 3543: Improve costed index scans for tuples by destructuring tuple operations when possible.
  This is an alternative to dolthub/go-mysql-server#3541. It's a simpler and more targeted change.
  In theory, dolthub/go-mysql-server#3541 lays the groundwork for more general-purpose analysis, since it could be used when tuples are used in additional operators (like inequalities), but it also adds additional complexity.
  👍 I'm not sure which approach is better.
vitess
- 469: add predicate to indexspec
- 🗄 467: Add ERWarnDeprecatedSyntax 1287
  Blocks #10983
Closed Issues
- 11095: REGEXP_REPLACE panics on TextStorage values: 'interface conversion: interface {} is *val.TextStorage, not string'
- 11088: CHAR_LENGTH fails with malformed string on valid UTF-8 replacement character (0xEFBFBD)
- ⚡️ 11065: Stored generated column stays stale after ON UPDATE CASCADE updates its base column
- 11070: CALL dolt_gc() left manifest referencing a chunk address not present on disk, rendering DB unopenable (v2.0.3)
- 11068: conjoin ENOSPC: panic + leftover partial nbs_table_* files cause unrecoverable disk-fill loop under supervised dolt-server
v2.0.5 Changes
May 20, 2026
🔀 Merged PRs
dolt
- 🔀 11076: More revert dirty-set rules to sync with git
  ⏪ Git will reject revert when there is anything staged, regardless of conflicts or not in the changed. This change makes dolt follow the same pattern.
  Related: #11073
- 11074: go/store/nbs: journal.go: Fix a bug which could result in broken databases after a process crash.
  If Dolt crashed immediately after creating an empty journal file, and before it wrote the initial set-root record to it, then the next time Dolt ran it would treat the root of the database as 0000....
  This could also happen for certain observed filesystem states after an operating system crash.
- 11072: go/store/nbs: Delete the in-flight table file in (*fileTablePersister).writeAndProtect when we experience an error on the write.
  Leaving it behind needlessly wastes disk space. It will never be usable and is in an indeterminate state.
  This is currently relevant even when FatalBehaviorFatal, because Conjoin's write is currently allowed to fail before we take the hard dependency on it. There are still some I/O errors which leave the file behind, including a failure at ftp.Open().
- ✅ 11063: Tests for IndexedJsonDocument.Compare
  ✅ When an IndexedJsonDocument compares a sql.JsonDocument of a different type, it falls back to using Json.Compare. This PR adds tests to ensure that the two implementations match.
- 🔒 10775: Fix open Dependabot security alerts
  🚑 Upgrade golang.org/x/image v0.18.0 -> v0.38.0 to address CVE for out-of-memory via crafted TIFF file. Upgrade @mikro-orm/core and @mikro-orm/mysql from v5 to v6.6.10+ to address critical SQL injection and high-severity prototype pollution vulnerabilities.
go-mysql-server
- 3551: star expression used in function
- 3550: modify CompareJSON to use sorted object keys
Closed Issues
v2.0.4 Changes
May 19, 2026
🔀 Merged PRs
dolt
- ⏪ 11073: dolt revert to more closely match git
- 11067: proto,go/serial: Bump some bazel version, some module versions.
- ⚡️ 11059: Fix SchemaTable.Updater panic on direct UPDATE dolt_schemas
  ⚡️ A direct UPDATE dolt_schemas reached SchemaTable.Updater, which panicked with "should never be called" — an unprivileged user could crash the SQL server with it. dolt_schemas is not directly modifiable via SQL, so this returns a clean error unconditionally instead of panicking; adds a regression test.
- 11058: go: sqle: Fix a dolt_branch_control bypass involving the session table cache.
  On a new connection, a SELECT against information_schema.tables or information_schema.columns would populate the session's table cache is a Table value that embedded a revision-less Database value. An incoming write request against the cached table would run its permissions check against the revision-less database, instead of the revisioned database which correctly encoded the branch the write was running against. This allowed connections to bypass dolt_branch_control, elevating to write permissions on all branches.
- ✅ 11057: Branch_control regression tests for more user-table write shapes
  ➕ Adds branch_control regression tests for the user-table write shapes that TestBranchControlBlocks wasn't already pinning; all were already correctly gated, so this is pure regression coverage with no behavior change.
- 11050: Gate branch_control on writable dolt system tables
  🔀 Most writable dolt system tables had no branch_control check, so a read- or merge-permission user could write to them; this gates the user-space tables (dolt_docs/ignore/query_catalog/nonlocal/tests via the shared createWriteableSystemTable helper), dolt_constraint_violations_, dolt_workspace_, and ConflictRootObjectTable with Permissions_Write. dolt_branches/dolt_remotes (already read-only), dolt_branch_control/namespace (own admin gating), and dolt_conflicts_ (already gated) are left as-is; tests cover every writer factory and pin the read-only behavior.
- ✅ 11049: Audit and test branch control coverage for dolt procedures
  Survey of dprocedures/dolt_*.go turned up four procedures with no branch_control check that mutate branch or working-set state. Three of them belong under Permissions_Write:
- 11047: Gate DOLT_CHECKOUT('<table>') with branch_control Write permission
  🔀 dolt_checkout(<table>) was previously ungated, so a user with a read or merge permission on a branch could clear working set changes. This gates dolt_checkout(<table>) while leaving dolt_checkout(<branch>) ungated
go-mysql-server
- 3551: star expression used in function
- 3546: Cache context to use for String() methods
  This is a replacement for:
  - dolthub/go-mysql-server#3525
    This accomplishes the same effective goal of passing context in the areas that we previously were not (primarily the String() function, which is load-bearing). The above PR changed the interfaces such that nodes and expressions no longer respected the fmt.Stringer interface. This PR instead caches the context inside of all nodes that need a context in their String() function by providing that context at node creation time. This was a tactic that we were already using before my original context threading PR:
  - dolthub/go-mysql-server#3513
    ...and should therefore be no worse than we were before I embarked on this journey.
    It's worth noting that the information_schema tables do not have a proper context inside of their String() function, as those tables are created when the engine is created, and SQL contexts only exist inside of connections/sessions. For now this doesn't impact anything as the Schema(ctx) methods (which use the context from String()) return a precomputed schema, however there are comments in place that warn about the nil context if those methods are ever modified.
- 3532: replace all decimal.Decimal with *apd.Decimal
Closed Issues
- 11066: Connection Close hangs indefinitely when attempting to usthe implicit sql transaction commit of aCALL DOLT_COMMIT`
- 11046: Overflowing TEXT type does not error and silently truncates, and mysql session variables do not work to make it error.

1
2
3
4
5
Next ›
Last »

dolt changelog

Dolt – Git for Data

Changelog History Page 1

🔀 Merged PRs

dolt

Closed Issues

🔀 Merged PRs

dolt

go-mysql-server

vitess

Closed Issues

🔀 Merged PRs

dolt

Closed Issues

🐎 Performance

🔀 Merged PRs

dolt

go-mysql-server

Closed Issues

🔀 Merged PRs

dolt

go-mysql-server

Closed Issues

🔀 Merged PRs

dolt

go-mysql-server

🛠 Fix

Why

✅ Tests

Examples

🔀 Merged PRs

dolt

go-mysql-server

🛠 Fix

Why

✅ Tests

Closed Issues

🔀 Merged PRs

dolt

go-mysql-server

vitess

Closed Issues

🔀 Merged PRs

dolt

go-mysql-server

Closed Issues

🔀 Merged PRs

dolt

go-mysql-server

Closed Issues

Changelog History

Page 1