Merged PRs

dolt

• 11028: drop remote db cache, Close() after each use
  SSH subprocesses created by sql-server instances were failing to clean up because the Close() method was never being called. This was the result of some caching done by GetRemoteDB in the sqle package. Most of this change is to remove sqle.DoltDatabaseProvider.GetRemoteDB() caching, allowing for push/pull operations to safely Close() remote databases after use. Thus, preventing the PID leak in the associated issue (#10897)
  Git remote database singletons are a special case. Previously the push operation only would cache these instances - which are expensive to create initially since they need to perform git operations to get in sync with the remote. There is no reason go Close() them though, so we keep a singleton for the duration of the sql-server process.
  Fixes: #10897
• 10990: replace all decimal.Decimal with *apd.Decimal
  Depends on dolthub/go-mysql-server#3532
• 10953: fix autogc load scheduler to be independent on number of CPUs
  Before, we had a threshold that was incorrectly calculating the threshold based off the number of CPUs.
  The original intention is to prevent AutoGC if a single CPU core exceeds 50% usage.
  We've determined that CPU Load itself is not a great metric to schedule AutoGC, but this is a fix for now.
  addresses: #10944

go-mysql-server

• 3539: Bug fix for dropping sort nodes
  Also fixed a couple under-specified goup concat tests.
  The latter were relying on a particular row storage order which is not guaranteed and broke when Dolt changed some encoding parameters.
• 3532: replace all decimal.Decimal with *apd.Decimal

Closed Issues

• 10944: Auto-GC never fires on multi-core systems: loadAvgGCScheduler threshold formula is inverted
• 9248: support returning clause in inserts like mariadb ?
• 10897: dolt sql-server leaks one ssh child process per CALL dolt_fetch against an ssh:// remote

Merged PRs

dolt

• 11040: fixed compat tests for a post-2.0 CI
• 11038: remove adapative encoding matrixes
  Now that adaptive encoding is on by default, we don't need to double our CI testing efforts anymore.
• 11035: Refactor prollyWriteSession and prollyTableWriter for individual table flushing
  This PR refactors flushing logic between prollyWriteSession and prollyTableWriter.
  Now, the prollyTableWriter is in charge of materializing the table and handling the auto increment logic, while the prollyWriteSession is in charge of keeping the workingSet up to date.
  The flush all table logic has been reworked in prollyWriteSession to use channels instead of a mutex.
  Additionally, this PR allows us to flush individual tables rather than every table in the session; this avoids concurrency overheads and no-op flushes.
• 11032: Let merge-permission users write through dolt_conflicts_
  Adds a branch-control carve-out so a user with only Permissions_Merge on a branch can resolve a merge that produced data conflicts by writing through dolt_conflicts_<t> and via DOLT_CONFLICTS_RESOLVE. Lets a PR reviewer on the SQL workbench finish a conflicting merge without being granted full write access on the target branch.
• 11030: Gate DELETE on dolt_conflicts_ with branch_control Write permission
• 11029: Allow index lookups on DOLT_DIFF table function.
  Currently, the DOLT_DIFF table function does not expose any indexes. But it can.
• 11020: .github: Factor out build-dolt and setup-dolt-config actions. Use them from workflows that want dolt binaries, like bats and sql-server-integration tests.
• 10853: chore: fix function name in comment to match actual function
  fix function name in comment to match actual function

Closed Issues

• 11041: FK action ON DELETE SET DEFAULT (and ON UPDATE SET DEFAULT) rejected at CREATE TABLE

Performance

Merged PRs

dolt

• 11006: Preserve tables absent from the index during checkout, reset, and rebase
  Tables present only in the working tree (never added to staging) were being deleted or incorrectly staged by the three commands.
  • Scope checkout . table list to HEAD and staged root
  • Update working and staged roots independently in the specific-table checkout case
  • Add MoveUntrackedTables helper for the working-tree preservation step in reset --hard and
    rebase
  • Apply rebase preservation via direct UpdateWorkingSet before SwitchWorkingSet
  • Fix dolt reset --soft <rev> to leave the index untouched
  • Rename ResetSoftToRef to MoveHeadToRef and resetSoftToRef to resetMixedToRef so names match
    behavior
• 11002: When dolt diff -r sql encounters a schema change, it should either print the full diff or return an error
  Previously, whenever a table had a schema change, dolt diff -r sql would skip printing the data diff for that table. It would print a message to stderr, but still return a 0 error code. This is misleading, especially if the diff command is called by an automated process.
  This PR improves the situations where we successfully render the data diff. In situations where we can't, we return a nonzero error code.

Closed Issues

• 3470: Subscribe to changes to a document/query (live query)
• 11014: ROW_COUNT function returns 0 on INSERT statement

Dolt 2.0 is the second major release of Dolt. It includes all the performance improvements and new features of Dolt 1.x releases in the 3 years since the 1.0 release, as well as several major milestones:

• Automatic garbage collection on by default
• Archival storage on by default
• Faster than MySQL on sysbench
• Beta support for Vector data
• Adaptive storage for TEXT, JSON, GEOMETRY, and BLOB types (similar to TOAST in Postgres)

Dolt 2.0 is backwards compatible with all 1.x releases of Dolt. Databases written by 2.x releases will not be readable by 1.x clients in all cases.

Merged PRs

dolt

• 11019: .github/actions/setup-go-toolchain: Make a common toolchain setup action which go test and bats test workflows can depend on.
  This is responsible for installing Golang toolchain and getting ICU4C in the environment so it can be used.
• 11017: flip flag for adaptive encoding

Closed Issues

Performance

Merged PRs

dolt

• 11011: Final 1.x PR before turning on adaptive encoding by default for 2.0
  This PR contains all the changes necessary to make CI pass with adaptive encoding on by default.

go-mysql-server

• 3539: Bug fix for dropping sort nodes
  Also fixed a couple under-specified goup concat tests.
  The latter were relying on a particular row storage order which is not guaranteed and broke when Dolt changed some encoding parameters.

Closed Issues

• 11014: ROW_COUNT function returns 0 on INSERT statement

This is a major version release to mark it as the last major version release before 2.0. There are no known backwards incompatible changes.

Merged PRs

dolt

• 11005: add a breaking change to schemas with adaptive columns
  Previously released versions had a fatal bug in adaptive encoded value handling that would lead to data loss during garbage collection or pulls. This change forces these clients to upgrade to a newer release before reading databases that use such encodings.
  Because no 1.x release of Dolt uses adaptive encoding without undocumented configuration flags, the fatal bug above does not impact any customer. This change prevents it from impacting any customers after the release of 2.0.

Closed Issues

Backwards Incompatible Changes

Different author and committer additions introduced are not interpretable by old Dolt clients. If you attempt to set an explicit committer that is different from the author, this will create a new field in storage. The dolt_log system table and procedure schemas have also been changed to be static. Compatibility for older clients is not guaranteed for all flags, e.g. --show-signature. Furthermore, the new Dolt client requires the Dolt server to be updated to this latest version to access all expected columns.

Merged PRs

dolt

• 10996: cleaned up binlog serialization logic
• 10995: Fixed deserialization for adaptive types during binlog replication
• 10993: Fix dolt rm --cached to allow unstaged working changes
  dolt rm --cached incorrectly rejected tables with unstaged working changes or tables already dropped from the working set.
  • --cached branch filters tables absent from working via HasTable before calling RemoveTables.
    Fix #10987
• 10983: Fix dolt_log table and procedure schema to be static and --decoration behavior
  dolt_log now exposes a fixed 12-column schema across the system table and procedure. Parents and signature columns remain opt-in via projection for the system table, and arguments in the dolt_log() procedure.
  • --parents and --show-signature no longer mutate the result of schema
  • Make parents and signature columns populate only when projected for dolt_log system table
  • --decorate=auto is deprecated in the sql-server context since TTY cannot be determined
  • --decorate=auto in CLI now correctly detects interactive terminal
  • Update bats coverage to be bidirectional for the server and client testing in compatibility
    Blocked by dolthub/vitess#467
• 10979: adaptive encoding tests for mysql client integration
• 10975: Use TARGET_ROW_SIZE table attribute to guide how aggressively we move adaptive encoded values out-of-band.
  TARGET_ROW_SIZE is a table attribute that can be set on tables. Dolt interprets this value as a size in bytes. When building a tuple, we attempt to keep the tuple under this size by moving adaptive-encoded values out-of-band until the size of the tuple falls below the threshold.
  Because Dolt does not allow tuples larger than 64K, we can always store the target value in 16-bits.
  The GMS interfaces use a uint64 for TARGET_ROW_SIZE, since other storage backends wouldn't necessarily have the same limit. When setting a value for TARGET_ROW_SIZE, Dolt verifies that it fits in 16 bits.
  Currently, this value can only be set while creating the table and can't be modified afterward.
• 10974: Db/git remote UI
  This PR updates git remotes to push a branch visible on the Git remote's UI that contains a file with some info about the git ref used as the dolt remote. Addresses #10525
• 10969: go-sql-server-driver tests for large adaptive and out-of-band values
  These tests exercise the replication, pull, and GC behavior for various kinds of schemas with large values that may be stored out of band. These tests failed before the inclusion of address serialization bug fixes from #10966
  Depends on dolthub/go-mysql-server#3533
• 10966: bug fix: write addresses field in tuples if they contain only adaptive encoded fields
• 10964: .github: ci-lambdabats-unix-adaptive.yaml: Add lambdabats DOLT_USE_ADPATIVE_ENCODING=true runs.
• 10962: /.github/workflows: fix maven link
• 10959: When merging, use a tuple builder to ensure that we generate the correct representation for the merged row.
  This matters for adaptive encoding columns, whose correct representation depends on other values in the row.
• 10958: Fix obscure race: make sure that RunF finishes before StopF in sqlServer.Start()
  This is a candidate for race conditions leading to nil pointer exceptions in some doltgres harness setups.
• 10952: adaptive encoding for JSON columns
  This will be turned on for the 2.0 release.
• 10941: build(deps): bump go.opentelemetry.io/otel from 1.40.0 to 1.41.0 in /go
  Bumps go.opentelemetry.io/otel from 1.40.0 to 1.41.0.
• 10933: build(deps): bump fast-xml-parser from 5.5.9 to 5.7.2 in /.github/actions/ses-email-action
  Bumps fast-xml-parser from 5.5.9 to 5.7.2.
• 10832: build(deps): bump go.opentelemetry.io/otel/sdk from 1.40.0 to 1.43.0 in /go
  Bumps go.opentelemetry.io/otel/sdk from 1.40.0 to 1.43.0.
• 10827: build(deps): bump github.com/aws/aws-sdk-go-v2/service/s3 from 1.78.0 to 1.97.3 in /go
  Bumps github.com/aws/aws-sdk-go-v2/service/s3 from 1.78.0 to 1.97.3.
• 10804: #10813 fix(checkout): enforce --no-overwrite-ignore in DOLT_CHECKOUT -b via direct SQL

  Summary

  When calling DOLT_CHECKOUT('-b', ...) directly via SQL (without --move), the --no-overwrite-ignore flag was silently ignored. CheckOverwrittenIgnoredTables was never called for the isMove=false path in checkoutNewBranch, so creating a branch from a non-HEAD start point would succeed even when ignored tables in the working set differed from the start point.
  The fix captures the current working roots before commitTransaction (which resets session state, making GetRoots return false afterward), then runs the ignored table check before switching the working set to the new branch.

  Changes

  • Call CheckOverwrittenIgnoredTables in the isMove=false path of checkoutNewBranch
  • Capture roots before commitTransaction to avoid session state reset
  • Add engine script tests and bats tests covering --no-overwrite-ignore and
    --overwrite-ignore with a non-HEAD start point
    Closes: #10813
• 10801: build(deps): bump lodash from 4.17.23 to 4.18.1 in /integration-tests/mysql-client-tests/node
  Bumps lodash from 4.17.23 to 4.18.1.* 10104: Add separate author and committer support
  Dolt now supports separate author (original intent) and committer (actual writer) identity for Dolt commits! Expect commit, cherry-pick, revert and merge operations (including SQL procedures) to pick up different author and committers automatically. The dolt_log, dolt_commits, dolt_diff, dolt_column_diff, dolt_branches, dolt_remote_branches system tables and respective table functions have been updated with author columns too.

  ⚠️ The committer columns in system tables or functions now show the committer identity instead of author. In old Dolt versions this was the result of no committer identity existing in storage, but has since been updated. We maintain backward-compatibility with this old format by duplicating the author identity into the committer identity. At serialization, however, the committer is only stored if the name or email is different from the author identity, allowing us to maintain the same commit hash history.
  ⚠️ We've appended the author columns under to end of each table to prevent issues with older Dolt clients.

New environment variables for committer identity are now available: DOLT_COMMITTER_NAME, DOLT_COMMITTER_EMAIL, DOLT_COMMITTER_DATE which take inspiration from their git counterparts.

⚠️ Environment variables (not SQL system variables) are only interpretable by the Dolt client. MySQL or alternative SQL clients will not pick these Dolt-specific environment variables up automatically in your terminal.

export DOLT_COMMITTER_NAME="Committer User"
export DOLT_COMMITTER_EMAIL="committer@example.com"
export DOLT_COMMITTER_DATE="2025-01-01T12:00:00Z"
dolt commit -m "Commit with custom committer date"

+----------------------------------+----------------+-----------------------+---------------------+--------------------------------------+--------------+-----------+------------------+---------------------+
| commit_hash                      | committer      | email                 | date                | message                              | commit_order | author    | author_email     | author_date         |
+----------------------------------+----------------+-----------------------+---------------------+--------------------------------------+--------------+-----------+------------------+---------------------+
| tdf81ch4ug4c9uc2p78rls1iihj95unn | Committer User | committer@example.com | 2025-01-01 12:00:00 | Commit with custom committer date    | 4            | Test User | test@example.com | 2025-11-19 10:15:47 |
| 0gonkh11sf1esld53b66jdpbu78sdq6i | Committer User | committer@example.com | 202...

Merged PRs

dolt

• 10947: go/store: nbs,types: Fix some error paths in GC.
  1. If gcCopier.copyTablesToDir failed after its writer.Finish() call succeeded, it would cancel the writer but leave gcc.writer != nil. Then markAndSweeper.Close would call gcc.cancel and get a spurious error from the failed writer.Cancel call.
  2. ValueStore.gc would fail to Close MarkAndSweeper if Finalize returned an error. The contract was that Close needed to be called on all paths.
  3. markAndSweepChunks dropped an error from newRotatingGCCopier.
  4. markAndSweeper Close early returned on an error from gcc.cancel, failing to close and cleanup incrementalGcc in that case.
• 10750: Add incremental mode for garbage collection
  This feature is enabled by providing the --incremental-file-size flag to dolt gc or call dolt_gc() with a positive value, and can be enabled for automatic GC with a setting in the server's config.yaml, eg:

  behavior:
  auto_gc_behavior:
  incremental_file_size: 1000000
  

  In this example, after GC has written 1000000 bytes of leaf chunks (chunks that do not reference other chunks), it will finish the chunk file and begin writing a new one.
  There are two main reasons to do this:
  • Chunks written this way don't need to be tracked in the GC "visited set", reducing memory usage.
  • If GC is interrupted (for instance, it may be terminated by the OS for using too much memory), the already-processed chunks will be preserved, and subsequent runs of GC will have less work to do and require less memory. This provides an escape hatch for the scenario where a user has not run GC in so long that GC requires more memory to run than is available.

go-mysql-server

• 3527: Truncate invalid UTF-8 on INSERT IGNORE and warn on LIKE with bad charset pattern
  • INSERT IGNORE with invalid UTF-8 in a utf8mb4 column now truncates at the first bad byte
  • LIKE with an invalid UTF-8 pattern emits warning 1300 and return no match
  • Exported TruncateInvalidUTF8 from sql/types
    Fix #10924
    Blocks #10926
• 3526: Update for functional expression index parser changes
  Parser changes support multiple functional expressions, or a mix of columns and functional expressions in an index. GMS still restricts functional indexes to a single functional expression, but that restriction will be removed in the next PR.
  Also includes a new test interface that Doltgres will use when integrating with functional indexes.
  Depends on: dolthub/vitess#466

vitess

• 466: Add parser support for multiple functional expressions in an index
• 465: go.mod: Bump to golang 1.26.2.
• 462: Added context to Injectable
  Needed for:
  • dolthub/go-mysql-server#3513

Closed Issues

• 10924: dolt table import should error when importing invalid charset
• 10945: RemotesAPI push: working-set-stale bug from #10807 still reproducible in v1.86.5

Performance

Merged PRs

dolt

• 10937: go: remotestorage: Stamp our remotesapi ClientCapabilities on outgoing requests.
  For now, we advertise that we handle HTTP/2 table file URL endpoints well.
• 10936: proto: Add client_capabilities URL-minting requests on remotesapi.
  Some Dolt clients deal with certain URLs better than others. In particular, older Dolt clients can see bad fetch performance in some network contexts when they are hitting HTTP/2 endpoints.
  Add a field, client_capabilities, on GetDownloadLocsRequest, StreamChunkLocationsRequest, RefreshTableFileUrl and ListTableFiles which allows a client to communicate its capabilities. For now, one capability exists: CLIENT_CAPABILITY_HTTP2_DOWNLOAD. Implementations of remotesapi can use the presence of the advertised capability to know it is safe to mint HTTP/2 capable URLs in a context where they previously would have minted only HTTP/1.1 URLs.
• 10935: key type conversion during foreign key checks
  This PR adds key type conversion for native encodings (encodings that don't have a TupleTypeHandler) for foreign key enforcement during merge. Postgres, but not MySQL, allows different but compatible types for the columns in foreign key constraints, e.g TEXT and VARCHAR. This means that Doltgres, but not Dolt, needs to sometimes convert the bytes of a tuple value from one encoding to another before an index lookup to determine if a constraint violation exists. Previously all such logic happened with TupleTypeHandler (DoltgresType was the main implementor). But with dolthub/doltgresql#2559, Doltgres is now using Dolt's native encodings where possible, e.g. StringEnc, StringAdaptiveEnc. This means this same logic must now work for these native encodings.
  Dolt continues to prevent foreign key constraints from being created between different types, following the MySQL behavior, but with this change we could choose to relax this limitation in the future.
• 10931: more adaptive encoding tests
• 10928: new compatibility testing
  These tests verify that identical columns added by two different client versions can be pulled from remotes.
  Also fixes an overflow bug in adaptive encoding (see Nick's commit) discovered during testing.
• 10927: [do not merge] New failing test for adaptive encoding
• 10925: go.mod: Bump to 1.26.2.
• 10920: Suppress S3 GetObject checksum WARN
  Fix #10895
• 10918: go,proto: remotesapi: Add a more efficient RPC, StreamChunkLocations, to use for fetch and pull.
  The current streaming RPC, StreamDownloadLocations, was a straight translation of the unary RPC GetDownloadLocations. We added streaming because it found it interacted much better with TCP and HTTP/2 window scaling. At the time, the RPCs were no reworked to take advantage of the stateful nature of the stream. Since then, the pipelined ChunkFetcher machinery has been added, which makes opportunities for reuse on the individual streaming RPC even better. We also added the RefreshTableFileUrl endpoint, which decouples a client's ability to continue using previously communicated table files from its need to see them in a GetDownloadLocsResponse in particular.
  StreamChunkLocations is transiting the exact same semantic payloads as StreamDownloadLocations. It's just not re-transmitting a bunch of stuff it does not need to. In particular:
  1. We transit table file URLs separately from the chunk locations. A table_file_id is assigned to a table file the first time the server tells the client about it. Then that same table_file_id is used to refer to that table file for all communicated chunk locations in all response messages on the same stream.
  2. We do not re-transit chunk hashes. The responses refer to the chunk hashes which were provided in the corresponding request by index. The client already knows them.
  3. We do not need to transit RefreshTableFileUrlRequest messages for the table files. The client can build these with its own knowledge.
     Those are three major improvements for bandwidth utilization. There are also some smaller things, like sending chunk_hashes as bytes instead of repeated bytes.
     This PR adds a features field in GetRepoMetadataResponse. That field lets a client know that it can call the new available endpoint. Otherwise the client continues calling StreamDownloadLocations.
     This PR adds both server-side and client-side implementations for the new endpoint. The server-side implementation ends up looking a lot like the existing StreamDownloadLocations code. It keeps some local maps so it can include the appropriate reference ids in the outgoing messages. The client-side implementation intentionally remains about as minimal as possible. In particular, it does not touch range coalescing or most aspects of the fetch pipeline. It targets just generating the StreamChunkLocationsRequest and handling the StreamChunkLocationsResponse messages. It translates the responses back into what StreamDownloadLocations would have generated before handing those pieces off to the rest of the fetch pipeline.
     In addition to unit tests, some machinery in remotesrv is updated so we can optionally disable advertising support for StreamChunkLocations. This allows us to update some integration tests so that they continue to exercise the StreamDownloadLocations code paths on both the client and the server.
• 10826: new interfaces to allow doltgres types to use standard encodings

go-mysql-server

• 3522: go.mod: Bump to golang 1.26.2.
• 3512: new signal error to skip modifying rows during DML operation
  This behavior is supported by postgres but not MySQL. This is a cleaner way to express that a row edit should be ignored and the rest of the operation continued.
• 3491: Feature: Indexed functional expressions
  Adds support for secondary indexes to contain functional expressions, which are then used to optimize queries with filters and join conditions that use that indexed functional expression.
  Initial performance testing between Dolt and MySQL shows that Dolt matches, or in some cases beats, MySQL's performance when these indexes are used.
  This initial implementation only supports a single expression in a functional index. Next steps for this work after this PR are:
  1. adding support to Doltgres
  2. extending support to multiple expressions in an index (functional expressions mixed with column names)
  3. add a sysbench test to compare query performance with indexed expression for Dolt and MySQL

Closed Issues

• 10939: dolt fsck fails on Windows with malformed path (leading backslash before drive letter)
• 10922: Bump Go toolchain to 1.25.9 to address CVE-2026-27143 and CVE-2026-27144
• 10895: S3 remotes: thousands of "Response has no supported checksum" WARN lines on push/pull due to pinned aws-sdk-go-v2 s3 v1.78.0
• 10892: AUTO_INCREMENT value lost after dolt backup restore

Merged PRs

dolt

• 10919: Sort adaptive encoding columns by size for out-of-band storage
  Note: This will currently change how we write rows with adaptive encoding columns. Rows written on older versions of Dolt can still be read, but writing them back will result in a new chunk hash. But since Dolt currently doesn't use adaptive encoding and Doltgres is in beta, that's acceptable.
  Claude's Summary
  • BuildPermissive now sorts adaptive encoding columns by size savings (largest first) before deciding which to move out-of-band, instead of visiting columns in sequential order
  • This keeps smaller values inline when possible, producing shorter tuples when columns have varying sizes
  • Added two new test cases verifying the largest-first ordering with 2 and 3 columns of different sizes
    Test plan
  • Existing TestTupleBuilderAdaptiveEncodings tests pass (including inline one of two columns)
  • New test largest value moved out-of-band first: two columns where column 0 is small and column 1 is large — verifies column 1 goes out-of-band while column 0 stays inline
  • New test three columns largest first ordering: three columns (medium, small, large) — verifies only the largest goes out-of-band
  • Full store/val package tests pass
• 10915: Fix fsck use earl.Parse to correctly resolve database path cross-platform
  fsck.go was using url.Parse to parse the database file URL. On Windows, url.Parse places the drive letter into the URL Host field rather than Path, causing dbfactory/file.go to construct an invalid file path.
• 10910: Threaded context through all GMS interfaces
  Threads the context as added by:
  • dolthub/go-mysql-server#3513
• 10908: go: remotestorage: reliable/http: Fix some misbehavior when ChunkFetcher is working against HTTP/2 endpoints.
  HTTP/2 frames responses differently from HTTP/1 and we see io.EOF on the response at slightly different times. A race in ChunkFetcher meant that it treated read-to-end-of-range-caller-wanted-and-was-Closed as a failure if the Close came in before the io.EOF from the read against the http.Response.Body.
  Fix that race and fix some behavior around our fetch health tracking related to it.
• 10906: Fix UPDATE when table has a BINARY primary key and a foreign key to use bytes.Equal
  Updating a row in a table with a BINARY or VARBINARY primarkey key and a foreign key caused a runtime panic. Any secondary index on such a table (including the index backing a foreign key constraint) would trigger it.
  • Fix isNoopUpdate to use bytes.Equal when comparing BINARY/VARBINARY column values
    Fix #10903
• 10893: Fix auto increment state after backup restore
  Fix database restored with dolt backup restore could generate incorrect AUTO_INCREMENT values when accessed through a still-running dolt sql-server.
  The restored table persisted the correct auto-increment value, but the server’s in-memory auto-increment tracker could be missing state for the restored database. The tracker now initializes missing table state from the restored table before allocating ids.
  Fix #10892
• 10889: use table and schema when adding/removing foreign key for Doltgres
  Depends on: dolthub/go-mysql-server#3514
• 10884: go: utils/config: file_config.go: Make concurrent reads and writes safe.
  Persisted SQL session variables land in at an instance of *FileConfig. It needs to be thread-safe.
  Fixes some transient crashes which can occur while under load and switching dolt_cluster role, for example.
• 10874: Feature: Indexed functional expressions
  Adds support for secondary indexes to contain functional expressions, which are then used to optimize queries with filters and join conditions that use that indexed functional expression.
  Initial performance testing between Dolt and MySQL shows that Dolt matches, or in some cases beats, MySQL's performance when these indexes are used.
  This initial implementation only supports a single expression in a functional index. Next steps for this work after this PR are:
  1. adding support to Doltgres
  2. extending support to multiple expressions in an index (functional expressions mixed with column names)
  3. add a sysbench test to compare query performance with indexed expression for Dolt and MySQL
• 10831: Preserve user GIT_SSH_COMMAND and block interactive SSH prompts without clobbering env
  When dolt pushes or fetches over a git+ssh remote, it was unconditionally overwriting the user's GIT_SSH_COMMAND environment variable with its own value (ssh -o BatchMode=yes). This broke workflows where users set GIT_SSH_COMMAND to pick a specific key.
  • GIT_SSH_COMMAND set by the user before invoking dolt is now preserved; dolt no longer overwrites it
  • Git subprocesses are now started in a new session (setsid on Linux/macOS, DETACHED_PROCESS on Windows) so SSH cannot reach the terminal to prompt for a passphrase or host key confirmation
  • Regression tests added against a real OpenSSH daemon
    Fix #10811

go-mysql-server

• 3516: Fix SHOW CREATE VIEW fail when underlying table is dropped
  MySQL returns a view's stored definition regardless of whether its underlying table exists. GMS re-resolved the view body at query time, which failed if the referenced table had been dropped.
  • Split SHOW CREATE TABLE and SHOW CREATE VIEW into separate build paths.
  • SHOW CREATE VIEW now reads the stored definition directly via ViewDatabase.GetViewDefinition
  • Extract showTargetInfo helper to deduplicate db/table/asOf extraction
    Fix #10902
    Blocked by dolthub/vitess#461
• 3514: handle foreign key errors for Doltgres
• 3513: Threaded context everywhere
  Integrators need to access the sql.Context in locations that it was not previously passed to, which has resulted in workarounds in some cases (such as storing the context in nodes) or missing functionality altogether (if a context is needed during function creation for example). This PR makes it such that the context is effectively passed everywhere.
  The one singular exception is in the String() function on nodes and expressions. Since those take advantage of the fmt.Stringer interface, they cannot accept a context without breaking that contract (which would also break %s and %v in the fmt package). This isn't considered too large an issue as strings are generally used for debugging, however if it is a core feature used by an integrator, then they'll still have to resort to workarounds.
• 3511: cache arithmetic type
  We spend a large amount of time determining the correct resulting expression type for Arithmetic expressions.
  Once the resulting type is determined for an math operation, it doesn't change for the remainder of the rows, so we should be able to cache this result and avoid many type checks and interface conversions.
• 3510: Ignore unique key errors when inserting into fulltext position table
  fixes #10882
  Ignore unique key errors when inserting into fulltext index.Position table (similar to how unique key errors are ignored for index.DocCount).
  We should consider using a non-unique index for index.Position and index.DocCount or restructuring how we're writing to these tables if we're always going to be ignoring unique key errors.
• 3491: Feature: Indexed functional expressions
  Adds support for secondary indexes to contain functional expressions, which are then used to optimize queries with filters and join conditions that use that indexed functional expression.
  Initial performance testing between Dolt and MySQL shows that Dolt matches, or in some cases beats, MySQL's performance when these indexes are used.
  This initial implementation only supports a single expression in a functional index. Next steps for this work after this PR are:
  1. adding support to Doltgres
  2. extending support to multiple expressions in an index (functional expressions mixed with column names)
  3. add a sysbench test to compare query performance with indexed expression for Dolt and MySQL

vitess

• 463: Relax error handling for COM_FIELD_LIST to avoid mysql client disconnecting
  The mysql client sends COM_FIELD_LIST commands by default (unless the -A option is given) to collect field metadata for all tables/views. If a view has a broken definition, then it was returning an error, which caused the mysql client to disconnect and reconnect. This change ignores errors when querying tables/views for a COM_FIELD_LIST command, which fixes the client disconnect issue and lets us match the MySQL server's behavior.
  GMS CI Tests: dolthub/go-mysql-server#3518
  Dolt CI Tests: #10912
  Fixes #10634
• 462: Added context to Injectable
  Needed for:
  • dolthub/go-mysql-server#3513
• [460]...