mirror/dolt
1
0
Fork 0
mirror of https://github.com/dolthub/dolt.git synced 2025-12-16 20:25:20 -06:00
Code Issues Packages Projects Releases 114 Wiki Activity

114 Releases 584 Tags

RSS Feed
  • v1.79.1 11a725d9a5
    Compare

    Pre-Release

    aronwk released this 2025-12-12 19:12:11 -06:00 | 13 commits to main since this release

    📅 Originally published on GitHub: Sat, 13 Dec 2025 01:27:17 GMT
    🏷️ Git tag created: Sat, 13 Dec 2025 01:12:11 GMT

    Downloads
  • v1.79.0 18589135b6
    Compare

    Stable

    aronwk released this 2025-12-11 16:47:14 -06:00 | 23 commits to main since this release

    📅 Originally published on GitHub: Thu, 11 Dec 2025 23:02:16 GMT
    🏷️ Git tag created: Thu, 11 Dec 2025 22:47:14 GMT

    Merged PRs

    dolt

    • 10188: Added JWT support for metrics endpoint authorization.
    • 10184: removed doltgres index implementation
      This change removes doltgres-specific index logic from Dolt and fixes various bugs in index lookup and type conversion logic that were preventing doltgres from using the unified index logic in the first place.
      See: https://github.com/dolthub/doltgresql/pull/2093
    • 10159: Add adapters.TableAdapter to handle dolt_status and other table conversions for integrators (a.k.a. Doltgres)
      A recent change to cherry-pick tests required dolt_status to display its staged column as a byte type to overcome MySQL's wire protocol being unable to distinguish Boolean types. This had the side affect of breaking Doltgres. This fix adds Dolt system table adapters for integrators (i.e. Doltgres). adapters.TableAdapter allows for tables in general to be wrapped or overwritten with different implementations.
      • Add adapters.TableAdapter to allow integrator's to overwrite or wrap existing table implementations.
      • Add adapters.DoltTableAdapterRegistry to automatically integrate said table adapters for Dolt system table through an interface available to integrators.
      • Remove explicit SUPERUSER privilege check in dolt_purge_dropped_databases as this should be handled by integrators.
      • Remove authentication handling in dolt_backup for Doltgres; now handled by dolthub/doltgresql#2068.
    • 10097: dolthub/dolt#10030: --filter contribution for dolt diff
      Author @codeaucafe
      Add --filter option to dolt diff, enabling filtering by specific change types and fixing issues from the earlier stalled PR (#3499).

      Users reviewing large diffs often need to focus on specific change types - deletes may need extra scrutiny while inserts are routine. With diffs spanning thousands of rows across multiple tables, grep isn't enough since updates show
      both additions and deletions.

      dolt diff --filter=added      # new tables/rows
dolt diff --filter=modified   # schema changes, row updates
dolt diff --filter=renamed    # renamed tables
dolt diff --filter=dropped    # dropped tables, deleted rows
dolt diff --filter=removed    # alias for dropped
dolt diff HEAD~1 --filter=dropped -r sql
      Close dolthub/dolt#10030
      Fix #1430
    • 10030: dolt/dolthub#1430: Add --filter option for dolt diff
      There was no action on the original #3499 for issue #1430; the PR was closed ~3 years ago. This PR fixes the open PR comments and updates the implementation details a bit for the RowWriting of filtered rows

    go-mysql-server

    • 3336: Return a helpful error message when attempting to use a table function where a non-table function is expected.
      Previously, we would return a "function not found" error, which was confusing and misleading.
      Fixes https://github.com/dolthub/dolt/issues/10187
    • 3334: Index lookup type conversion issues
      This PR addresses type conversion semantics during key lookups. Some type conversions were insufficient for Doltgres, and some were simply incorrect, notably the behavior when a value being converted was out of range, which could produce incorrect results.
      Other fixes addressed:
      • New ExecBuilderNode interface to allow Doltgres to correctly use the custom builder overrides when building row iters
      • Corrected behavior for IN and NOT IN used in index lookups for doltgres
        Tests for some of these changes only exist in Doltgres, will address before merging.
        See: https://github.com/dolthub/doltgresql/pull/2093
    • 3333: fix overflow indexed table access
      There's a bug where filtering by a key that overflows the index column type results in incorrect lookups.
      When converting the key type to the column type, we ignore in OutOfRange results, and use the max/min of the corresponding type. As a result, we perform lookups using the wrong key.
      Changes:
      • sql.Convert() returns if the conversion result is InRange, Overflows, or Underflows.
      • Reduce number of potential ranges by ignoring impossible ones.
      • Fixes HashIn to handle overflowing keys.
      • Added tests for out of range key conversions.
    • 3332: Fix create view error message
      This fixes: https://github.com/dolthub/dolt/issues/10177
    • 3331: Introduce notion of conditional equivalence sets in FDS for optimizing outer joins.
      Fixes https://github.com/dolthub/dolt/issues/9520
      In Functional Dependency Analysis, equivalence sets are sets of columns which have been determined to always be equal to each other. During join planning, we walk the join tree, read the join filters, and use these filters to compute equivalence sets which can inform the analysis.
      However, we currently only look at filters on inner joins, because filters on outer joins do not unconditionally imply equivalence.
      For example, in the following join query: 
      SELECT * FROM table_one LEFT JOIN table_two ON table_one.one = table_two.two
      It cannot be said that table_one.one and table_two.two have equal values in the output. Any of the following are valid rows in the final output:
      table_one.one table_two.two
      1 1
      1 NULL
      NULL NULL
      In order to record this filter and include it in FDS, we need to tweak the definition of equivalence sets slightly.
      This PR adds conditional equivalence sets, which consist of two column sets: conditional columns and equivalent columns. A conditional equivalence set should be interpreted as: "IF at least one of the columns in conditional is not null, THEN all of the columns in equivalent are equal." This matches the behavior of left joins.
      We could implement regular equivalence sets as conditional equivalence sets with an empty conditional, but this PR keeps them separate to avoid complicating existing logic.
      It's worth noting that we deliberately don't check if the columns are non-null at the time that the equivalence set is created. This is deliberate, because when equivalence sets are inherited by parent nodes, this can change for outer joins, and when evaluating whether a join can be implemented as a lookup, we analyze the child node using filters and equivalence sets from the parent, but with the child's nullness information.
      Thanks to Angela, who worked on the investigation with me, wrote the original version of this feature (https://github.com/dolthub/go-mysql-server/pull/3288), and wrote the plan test for this PR.

    vitess

    • 445: /go/vt/sqlparser: support float8
    • 444: go/mysql: server.go: Add a callback on Handler, ConnectionAuthenticated, which is called immediately after the connection is authenticated.
      This allows a server implementation to know the authenticated user without waiting for the first command interactions, such as ComQuery or ComInitDB.

    Closed Issues

    • 10174: Does Dolt Support Minio Storage for Remotes and Backups?
    • 10059: Incorrect collation returned by case expression
    • 10187: Using a table function where a non-table function is expected results in confusing "function not found" error
    • 10157: Unexpected ANTI JOIN Result
    • 1430: dolt diff should support --filter option
    • 10136: DOLT_BACKUP Restore Requires Existing Database Context and Service Restart to Recognize New Database

    Note on Incompatibility

    • Dolt 1.79.0 has support for new sql-server config parameters. Due to the strict yaml parser used for server configuration, a 1.79.0 config will not work with older versions of Dolt.
    Downloads
  • v1.78.8 4fd223dfda
    Compare

    Stable

    aronwk released this 2025-12-08 22:40:11 -06:00 | 103 commits to main since this release

    📅 Originally published on GitHub: Tue, 09 Dec 2025 04:55:47 GMT
    🏷️ Git tag created: Tue, 09 Dec 2025 04:40:11 GMT

    Merged PRs

    dolt

    • 10183: go: store/datas/pull: pull_chunk_tracker.go: Optimize memory use when backing up to an AWS remote.
      PullChunkTracker is responsible for making the HasMany calls against the destination and batching up absent hashes into HashSets which will be delivered to GetManyCompressed and eventually written into table files which are uploaded. This code is used for both pull and push, when the destination is the "local" database or when destination is the remote database respectively. It is used when the remote is both doltremoteapi, thus every HasMany call is an RPC, and when the remote is something like file:// or aws://, thus the table file indexes for the remote are in memory and HasMany calls are very quick.
      Different operational characteristics of the various dependencies mean that sometimes a Pull is prone to build up large sets of hashes waiting for HasMany calls, whereas other times it is prone to build up large sets of absent hashes which are waiting for the fetcher thread(s) to take them.
      Previously, PullChunkTracker was structured to accumulate HasMany responses and wait to batch them into appropriately-sized batches for GetManyCompressed until the fetcher threads asked for them. This meant that if HasMany batches were very small, because HasMany was very fast, we would accumulate a large number of very small HashSets. These HashSets would take up large amounts of memory. Accumulating the batches as the HasMany responses come in is more memory efficient and should be no slower - we will always accumulate the full batches, and in basically the same order.
      Tested by pushing a large database to an AWS remote and memory profiling the result.
    • 10164: dolthub/dolt#10136: Fix dolt_backup to work in non-Dolt directories
      Fixes dolthub/dolt#10136
      • Fix dolt_backup to work in non-Dolt directories; this amends the dolt.go boolean expression for commands that accept non-Dolt directories into a searchable map.
      • Remote sql-backup.bats from local-remote.bash so it also gets run against server.

    go-mysql-server

    • 3332: Fix create view error message
      This fixes: https://github.com/dolthub/dolt/issues/10177
    • 3328: Avoid underestimating rows in outer joins.
      When computing row estimates for joins, if the join can't be optimized into a lookup join or a merge join, we use stats to predict the fraction of pairwise combinations of left and right rows that will match and estimate the number of result rows as leftRows * rightRows * selectivity.
      This is correct for inner joins, but not correct for outer joins, because left joins guarantee at least one result per left row, and full outer joins guarentee at least one result per left or right row.
      Consider a left join where left.RowCount() is much greater than right.RowCount(), and every row of the relevant column is distinct (so left.RowCount() == left.DistinctCount(). In that case, selectivity == 1.0 / left.RowCount(), and the estimated cardinality is equal to:
      left.RowCount() * right.RowCount() * selectivity == left.RowCount() * right.RowCount() * (1.0 / left.RowCount()) ==right.RowCount().
      If the selectivity of the join is very small, this could result in a row estimate that is lower than the guaranteed minimum, which can cause the join planner to pick bad plans. In the worst case it could cause us to favor an unoptimizable join order over an optimizable one.
      A common impact of this change is to now favor hash joins for left joins when the right is much smaller than the left. This makes sense: iterating over the smaller right table once and building a hash table in memory is going to be much faster than doing a table lookup for each left row.

    Closed Issues

    • 9520: PRIMARY KEY isn't always used in left joins
    • 10177: need better error message when creating view with conflicting name
    • 10176: panic during dolt_rebase: panic: expected false
    • 10136: DOLT_BACKUP Restore Requires Existing Database Context and Service Restart to Recognize New Database
    • 10157: Unexpected ANTI JOIN Result
    • 10086: Dolt Unable to Resolve Default Branch Head Error
    Downloads
  • v1.78.7 628b9dcce5
    Compare

    Stable

    aronwk released this 2025-12-05 17:21:23 -06:00 | 112 commits to main since this release

    📅 Originally published on GitHub: Fri, 05 Dec 2025 23:36:47 GMT
    🏷️ Git tag created: Fri, 05 Dec 2025 23:21:23 GMT

    Merged PRs

    dolt

    • 10178: Report merge conflict when merging a JSON document that is NULL in the common ancestor.
      When attempting to merge concurrent changes to a JSON document, Dolt should check whether the document is NULL in either branch or the common ancestor, and correctly report when this results in a merge conflict.
    • 10155: Update datetime types to correct precision for dolt system tables
      fixes #10128
      depends on dolthub/go-mysql-server#3323
    • 10120: Allow dolt_commit_diff_ to diff against HEAD
      Previously it was not possible to use 'HEAD' as a filter value on dolt_commit_diff_ system tables. This PR adds support and additional tests.

    go-mysql-server

    • 3328: Avoid underestimating rows in outer joins.
      When computing row estimates for joins, if the join can't be optimized into a lookup join or a merge join, we use stats to predict the fraction of pairwise combinations of left and right rows that will match and estimate the number of result rows as leftRows * rightRows * selectivity.
      This is correct for inner joins, but not correct for outer joins, because left joins guarantee at least one result per left row, and full outer joins guarentee at least one result per left or right row.
      Consider a left join where left.RowCount() is much greater than right.RowCount(), and every row of the relevant column is distinct (so left.RowCount() == left.DistinctCount(). In that case, selectivity == 1.0 / left.RowCount(), and the estimated cardinality is equal to:
      left.RowCount() * right.RowCount() * selectivity == left.RowCount() * right.RowCount() * (1.0 / left.RowCount()) ==right.RowCount().
      If the selectivity of the join is very small, this could result in a row estimate that is lower than the guaranteed minimum, which can cause the join planner to pick bad plans. In the worst case it could cause us to favor an unoptimizable join order over an optimizable one.
      A common impact of this change is to now favor hash joins for left joins when the right is much smaller than the left. This makes sense: iterating over the smaller right table once and building a hash table in memory is going to be much faster than doing a table lookup for each left row.
    • 3326: Skip expected estimates and analysis for keyless table plan tests
      This is because of https://github.com/dolthub/dolt/issues/10160
      These tests were supposed to be disabled in a previous PR, but plangen regenerated them.
      Thus, this PR provides a way explicitly tell plangen not to generated expected estimates, while still generating missing estimates as the default behavior.
      The difference between setting an expected value to "skip" vs omitting is how plangen treats it: plangen will generate omitted estimates (since we typically want them) but will avoid generating estimates that are explicitly skipped.
    • 3325: Make IsNullable return true for log and math functions where applicable
      fixes dolthub/dolt#10102
      fixes dolthub/dolt#10157
      Like mentioned in #3308, we should do an audit of all our functions to make sure IsNullable correctly returns true if Eval can return nil for a non-nil child value. I've filed dolthub/dolt#10161 to ensure that it's on our to-do list.
    • 3322: custom AppendDateFormat
      The time package's implementation of AppendDate contains additional checks and formatting options that are not necessary. Implementing a cheaper version gives us better performance.
      Benchmarks: https://github.com/dolthub/dolt/pull/10150#issuecomment-3601374094
    • 3320: Mark innodb_lock_wait_timeout as being in both global and session scopes
      We had the innodb_lock_wait_timeout system variable marked only as being in global scope, but in MySQL, it is in global and session scope.

    Closed Issues

    • 10157: Unexpected ANTI JOIN Result
    • 10174: Does Dolt Support Minio Storage for Remotes and Backups?
    • 10128: DATETIME values with microseconds are not comparable unless the literal includes the hidden fractional seconds
    • 10102: Unexpected ANTI JOIN Result
    Downloads
  • v1.78.6 3c8b436917
    Compare

    Stable

    aronwk released this 2025-12-04 12:48:10 -06:00 | 138 commits to main since this release

    📅 Originally published on GitHub: Thu, 04 Dec 2025 19:03:18 GMT
    🏷️ Git tag created: Thu, 04 Dec 2025 18:48:10 GMT

    Merged PRs

    dolt

    • 10163: Bug fix: correctly copy check constraints
      A customer reported a strange behavior where check constraints were getting corrupted/duplicated. The root cause was a bug in the CheckConstraint.Copy() implementation that wasn't returning a copy of the underlying checks, and allowed another part of engine to modify the check constraints accidentally.
    • 10149: Change nodeCache from array to slice
      Arrays in golang are pass by value, whereas slices are pass by reference, so the nodeCache was getting copied everywhere.
    • 10147: dolthub/dolt#10138: Fix dolt_backup sync and sync-url not taking working set changes in transaction
      Fixes dolthub/dolt#10138
    • 10146: dolthub/dolt#7628: Amend dolt_backup DoltgresSQL privilege check for server only
      Fixes #7628
      • Fix dolt_backup support in dolthub/dolt driver.
      • Fix Erlang MySQL integrations test to use locked version of Elixir 1.18.3 base docker image.
    • 10126: .github,go/utils/{publishrelease,rpmbuild}: Add a basic RPM build to the published release artifacts for Dolt.
      These RPMs include the statically linked Dolt binary, installed at /usr/local/bin/dolt. They work on x86_64 and aarch64 RPM-based Linux distributions. To install them, download the appropriate dolt-...-1.{x86_64,aarch64}.rpm file from the GitHub release artifacts and run sudo rpm -i downloaded_file.rpm on it.
    • 10078: journal errors, recovery, and testing
      Variety of changes to provide assist in healthy journals.
      1. Detect journal data loss by looking for parsable objects after unparsable blocks. (root hash followed by another root or chunk). Data loss detection prevents loading of DB, and produced error message in logs.
      2. Removed null padding during journal file creation.
      3. Automatically truncate journal files when they do not contain any dataloss after parsable portions of the file.
      4. Refactor FSCK to enable running when database is not loadable.
      5. Provide FSCK flag --revive-journal-with-data-loss to backup and repair journal file

    go-mysql-server

    • 3322: custom AppendDateFormat
      The time package's implementation of AppendDate contains additional checks and formatting options that are not necessary. Implementing a cheaper version gives us better performance.
      Benchmarks: https://github.com/dolthub/dolt/pull/10150#issuecomment-3601374094
    • 3321: rewrite last query info
      Reimplement LastQueryInfo to not use a map of *atomic.Value with constant keys
      benchmarks: https://github.com/dolthub/dolt/pull/10148#issuecomment-3600831594
    • 3319: Fix TimestampFuncExpr and SetOp in stored procedures
      Changes:
    • 3318: dolthub/dolt#10113: Fix DELETE queries with NOT EXISTS uninitialized subqueries
      Fixes dolthub/dolt#10113
      DELETE queries with NOT EXISTS subqueries failed because EXISTS expressions did not set the refsSubquery flag. This caused DELETE queries to use a simplified analyzer batch that skipped subquery initialization, leaving subqueries without execution builders.
      • Refactor EXISTS expression building to reuse buildScalar() for *ast.Subquery, ensuring refsSubquery is set.
      • Capture the table node for simple DELETE queries before buildWhere() wraps it.
      • Separate concerns between explicit targets and implicit targets in a bool, but keep all targets in the same list to handle wrapped targets.
      • Add WithTargets() method to update targets without changing the explicit/implicit flag.
      • Fix offsetAssignIndexes() fast path to skip when virtual columns are present, using the full indexing path instead.

    Closed Issues

    • 10134: Dolt and Debezium - GTID error in debezium-connector-mysql
    • 10138: Is dolt_add("-A") Required Before Calling the Stored Procedure dolt_backup("sync", "name")?
    • 10141: Adding a procedure around a CTE query causes panic
    • 10142: Referencing a procedure variable inside a non-trivial query fails
    • 10137: Data returned from dolt sql-server is different from dolt sql -q
    • 10113: Dolt attempted to evaluate uninitialized subquery , SQL compatibility adjustment

    Performance

    Read Tests MySQL Dolt Multiple
    covering_index_scan 1.82 0.55 0.3
    groupby_scan 13.95 11.65 0.84
    index_join 1.5 1.96 1.31
    index_join_scan 1.47 1.34 0.91
    index_scan 34.33 22.69 0.66
    oltp_point_select 0.2 0.28 1.4
    oltp_read_only 3.82 5.28 1.38
    select_random_points 0.35 0.58 1.66
    select_random_ranges 0.39 0.57 1.46
    table_scan 34.33 28.16 0.82
    types_table_scan 74.46 65.65 0.88
    reads_mean_multiplier 1.06
    Write Tests MySQL Dolt Multiple
    oltp_delete_insert 8.43 6.55 0.78
    oltp_insert 4.18 3.19 0.76
    oltp_read_write 9.22 11.65 1.26
    oltp_update_index 4.25 3.25 0.76
    oltp_update_non_index 4.25 3.19 0.75
    oltp_write_only 5.28 6.32 1.2
    types_delete_insert 8.43 6.91 0.82
    writes_mean_multiplier 0.9
    TPC-C TPS Tests MySQL Dolt Multiple
    tpcc-scale-factor-1 93.72 36.25 2.59
    tpcc_tps_multiplier 2.59
    Overall Mean Multiple 1.52
    Downloads
  • v1.78.5 41e5bb01bf
    Compare

    Stable

    aronwk released this 2025-11-26 21:29:24 -06:00 | 179 commits to main since this release

    Merged PRs

    dolt

    • 10110: dolthub/dolt#7628: Refactor dolt backup to use SQL interface
      Fixes dolthub/dolt#7628
      The dolt backup command now interfaces through SQL to execute stored procedure dolt_backup. The dolt_backup procedure now supports HTTP and HTTPS URLs for add, restore, and sync-url parameters as a result. AWS flags are also supported for the above too, but only outside of the sql-server (this goes for both CLI and SQL interfaces).
      • Removed DoltEnv-based subcommand implementations and replaced them with calls to stored procedure dolt_backup.
      • Updated schema for dolt_backups to include params column.
      • Added support for HTTP and HTTPS in dolt_backup procedure's add, restore, and sync-url parameters. We implicitly use the dialer provided by Session.Provider() to get remote databases.
      • Added helper/remotesrv-common.bash with remotesrv_start, remotesrv_stop, and wait_for_port functions to test dolt backup against HTTP remote server.
      • Removed backup.bats from local-remote.bash list so tests run on remote server.
      • Add AWS flags --aws-region, --aws-creds-type, --aws-creds-file and --aws-creds-profile to dolt backup restore.'
      • Switch TestDoltStoredProcedures to use local file system due to limitation on InMem.TmpDir() incompatibility.

    go-mysql-server

    • 3318: dolthub/dolt#10113: Fix DELETE queries with NOT EXISTS uninitialized subqueries
      Fixes dolthub/dolt#10113
      DELETE queries with NOT EXISTS subqueries failed because EXISTS expressions did not set the refsSubquery flag. This caused DELETE queries to use a simplified analyzer batch that skipped subquery initialization, leaving subqueries without execution builders.
      • Refactor EXISTS expression building to reuse buildScalar() for *ast.Subquery, ensuring refsSubquery is set.
      • Capture the table node for simple DELETE queries before buildWhere() wraps it.
      • Separate concerns between explicit targets and implicit targets in a bool, but keep all targets in the same list to handle wrapped targets.
      • Add WithTargets() method to update targets without changing the explicit/implicit flag.
      • Fix offsetAssignIndexes() fast path to skip when virtual columns are present, using the full indexing path instead.

    Closed Issues

    • 10113: Dolt attempted to evaluate uninitialized subquery , SQL compatibility adjustment
    • 7628: Migrate dolt backup to SQL
    • 10008: Implement client certificate authentication
    Downloads
  • v1.78.4 bdd9081555
    Compare

    Stable

    aronwk released this 2025-11-25 17:21:57 -06:00 | 220 commits to main since this release

    Merged PRs

    dolt

    • 10124: go/cmd/dolt: Allow the Dolt CLI to connect to a running dolt sql-server which is configured with require_secure_transport: true.
      When Dolt CLI is running in a directory with a corresponding running sql-server process, it will connect to the server process and complete its work using SQL statements. Previously, the Dolt CLI was configured to always connect on a plaintext TCP connection for these connections. That meant it did not work for servers configured with require_secure_transport: true. One consequence was that the published Dolt dockerhub image did not work with require_secure_transport: true, since that image runs dolt sql against the running server as part of its entrypoint.
      This changes dolt CLI to connect over (non-verified) TLS if such as an option is presented by the server. The CLI still falls back to plaintext as well.
      Dolt CLI still does not work when the server is configured with require_client_certificate, since Dolt CLI does not currently have a way to configure its presented client certificate and private key. As a consequence, at least for the time being, the published DockerHub images for Dolt do not work with require_client_certificate: true.

    Closed Issues

    Downloads
  • v1.78.3 01912160bd
    Compare

    Stable

    aronwk released this 2025-11-24 17:36:56 -06:00 | 223 commits to main since this release

    Merged PRs

    dolt

    • 10111: Implement DOLT_JSON_DIFF table function
      This defines a new system table function DOLT_JSON_DIFF(arg1, arg2)
      For each difference between the two provided JSON objects, this function produces a row describing the path to the changed value, and the before and after values. It can be used in a lateral join with other system tables to show changes in multiple rows or across multiple commits.
      The tests in dolt_json_diff_test.go are go tests for the table function, confirming that it has the same behavior as the unit tests for the underlying differ.
      The added engine tests are used to test more complicated behavior, such as using this table function in a lateral join.
    • 10096: Add require_client_cert to sql server configuration options
      Adds a new require_client_cert property to the listener section of a sql server configuration file. When enabled, clients must present a certificate and must connect over a secure connection. If ca_cert is also provided in the server's configuration, the provided client cert will also be verified against the server's CA cert.
      Note that this mode prevents dolt sql from being able to connect to a running Dolt SQL server, since dolt sql will connect to the server but does not have a valid client cert and private key to use.
      Related to https://github.com/dolthub/dolt/issues/10008
      Doc updates https://github.com/dolthub/docs/pull/2718

    go-mysql-server

    • 3315: cache static groupby schema
      The schema throughout a groupby query does not change, so we should not be recreating one for the grouping key each time.
      Benchmarks: https://github.com/dolthub/dolt/pull/10119#issuecomment-3564876007
    • 3314: server/handler: Add ConnectionAuthenticated callback which Vitess can call once the connection is authenticated.
      Previously gms relied on the ComInitDB callback to update the processlist with the currently authenticated user. This resulted in the processlist showing "unauthenticated user" for connections which were already authenticated but which had not issued a ComInitDB. Those connections could issue queries which would also appear in the process list. Adding an explicit callback when the authentication is successful and allowing the processlist entry to be Command Sleep with an authenticated user even when no database is selected is more correct behavior here.
    • 3310: Split Iter.Next(), RowToSQL, and callback into separate threads
      This PR expands on an optimization where we separate iter.Next() and RowToSQL + callback() into two separate threads. Now, iter.Next(), RowToSQL, and callback() all run in their own goroutines with corresponding buffered channels communicating between them.
      Additionally, this PR tidys up the resultForDefaultIter and resultForValueIter code.
      Benchmarks: https://github.com/dolthub/dolt/pull/10103#issuecomment-3552282315

    vitess

    • 444: go/mysql: server.go: Add a callback on Handler, ConnectionAuthenticated, which is called immediately after the connection is authenticated.
      This allows a server implementation to know the authenticated user without waiting for the first command interactions, such as ComQuery or ComInitDB.
    • 443: Updating auth interfaces to pass connection
      Enables implementations to have access to the connection. Needed as part of mutual TLS auth work so that implementations can validate connection properties. Also matches the interface definitions in the official vitess repo.

    Closed Issues

    Downloads
  • v1.78.2 1dc3732096
    Compare

    Stable

    aronwk released this 2025-11-20 13:20:52 -06:00 | 244 commits to main since this release

    Merged PRs

    dolt

    • 10095: support tls in the dolt metrics http endpoint

    go-mysql-server

    • 3310: Split Iter.Next(), RowToSQL, and callback into separate threads
      This PR expands on an optimization where we separate iter.Next() and RowToSQL + callback() into two separate threads. Now, iter.Next(), RowToSQL, and callback() all run in their own goroutines with corresponding buffered channels communicating between them.
      Additionally, this PR tidys up the resultForDefaultIter and resultForValueIter code.
      Benchmarks: https://github.com/dolthub/dolt/pull/10103#issuecomment-3552282315
    • 3309: unsafe methods in SQL and SQLValue
      This PR adds unsafe string access to EnumType.SQLValue() and SetType.SQLValue().
      Additionally, uses string concat over SPrintf().
      Benchmarks: https://github.com/dolthub/dolt/pull/10101#issuecomment-3551137003
    • 3308: make IsNullable return true for nullable datetime functions
      fixes dolthub/dolt#10092
      I updated the datetime functions' IsNullable function based on whether they could return nil, using function_queries.go from #3305 as a reference.
      We should probably do an audit of all our functions to make sure IsNullable is correct.

    Closed Issues

    Performance

    Read Tests MySQL Dolt Multiple
    covering_index_scan 1.86 0.55 0.3
    groupby_scan 13.7 13.7 1.0
    index_join 1.5 2.07 1.38
    index_join_scan 1.5 1.34 0.89
    index_scan 34.33 23.95 0.7
    oltp_point_select 0.2 0.28 1.4
    oltp_read_only 3.82 5.28 1.38
    select_random_points 0.35 0.58 1.66
    select_random_ranges 0.39 0.57 1.46
    table_scan 34.95 28.16 0.81
    types_table_scan 75.82 80.03 1.06
    reads_mean_multiplier 1.09
    Write Tests MySQL Dolt Multiple
    oltp_delete_insert 8.43 6.55 0.78
    oltp_insert 4.18 3.19 0.76
    oltp_read_write 9.22 11.65 1.26
    oltp_update_index 4.25 3.25 0.76
    oltp_update_non_index 4.25 3.19 0.75
    oltp_write_only 5.28 6.32 1.2
    types_delete_insert 8.58 6.91 0.81
    writes_mean_multiplier 0.9
    TPC-C TPS Tests MySQL Dolt Multiple
    tpcc-scale-factor-1 93.7 36.51 2.57
    tpcc_tps_multiplier 2.57
    Overall Mean Multiple 1.52
    Downloads
  • v1.78.1 256bfca6d9
    Compare

    Stable

    aronwk released this 2025-11-18 19:47:04 -06:00 | 258 commits to main since this release

    Merged PRs

    dolt

    • 10094: go/store/nbs: Fix NomsBlockStore Conjoin against AWS S3 when the AWS S3 endpoint requires a Content-Length header.
      AWS Go SDK needs an io.ReadSeeker in the UploadPartInput in order to supply a Content-Length header. Supplying an io.MultiReader was resulting in an error.
      Fix this for now by making a temporary copy of the data and using a bytes.NewReader instead.

    go-mysql-server

    • 3308: make IsNullable return true for nullable datetime functions
      fixes dolthub/dolt#10092
      I updated the datetime functions' IsNullable function based on whether they could return nil, using function_queries.go from #3305 as a reference.
      We should probably do an audit of all our functions to make sure IsNullable is correct.
    • 3306: dolthub/dolt#10083: Honor definer privileges when rebinding views
      Fixes dolthub/dolt#10083
      View rebinding no longer requires the invoker to have CREATE VIEW grant if the definer already did.
      • Introduce builder-level mockDefiner to clone the cached privilege state with explicit global grants.
      • Update resolveView to mock definer for CREATE VIEW grant since it's implicitly required to exist.
    • 3305: Fix datetime functions to return correct results for 0 and false
      Fixes dolthub/dolt#10075
      Our datetime functions were not returning the correct results for 0 and false. This was because we were using 0000-01-01 as zeroTime (which evaluates to true using Go's time.IsZero) and then extracting datetime information from that timestamp. Using 0000-01-01 as zeroTime was also giving incorrect results for some functions when the input timestamp was actually 0000-01-01, since it was being equated as zeroTime.
      Also, depending on whether false was read as false or 0, we were also not able to convert it to zeroTime.
      This fix involves updating zeroTime to time.Date(0, 0, 0, 0, 0, 0, 0, time.UTC), which has the timestamp -0001-11-30. Since negative years are not valid in MySQL, this timestamp would not conflict with a non-zero timestamp. We also add in checks for zeroTime to make sure functions return the correct value from zeroTime instead of simply extracting datetime information from the timestamp.
      Dolt bump PR: dolthub/dolt#10084

    Closed Issues

    • 10092: Unexpected ANTI JOIN Result
    • 10083: View SELECT requires invoker to have CREATE VIEW
    • 10075: Unexpected DAYOFMONTH Result
    Downloads