Merged PRs

dolt

• 10140: Full passthrough of Doltgres overrides
  Related PRs:
  • dolthub/go-mysql-server#3303
  • dolthub/doltgresql#2009

go-mysql-server

• 3342: Set SubqueryAlias.OuterScopeVisibility to true if inside trigger scope
  Fixes #10175
  Trigger scopes were being included when determining exec indexes for SubqueryAlias child nodes but were not actually passed down to child iterators during rowexec (code). As a result, we were getting index out of bounds errors since the trigger scopes were not included in the parent row.
  Since there's no easy way to separate the trigger scope columns out from the rest of the parent row during rowexec, it was easier to just mark SubqueryAlias.OuterScopeVisibility inside triggers to true. I think it technically does make sense here because the trigger scope is an outer scope that the SubqueryAlias does have visibility of, but I added a TODO comment in case this is incorrect.
• 3340: enable native indexes on all in-memory tables by default
  Also simplifies the test harness setup by removing the non-native-index cases.
  Fixes dolthub/go-mysql-server#3338
• 3339: Do not erase projections for insert sources inside triggers
  part of #10175 (see example 2)
  Erasing projections for insert sources inside triggers was causing the wrong columns to be selected when the trigger is executed. This is because the exec indexes in Project nodes inside the trigger logic account for the prepended trigger row and is needed to "trim" away the prepended row to get the right columns. The Project node that ultimately wraps the insert source, which re-projects it to match the insert destination, assumes the correct columns have already been fetched by its child node so does not account for the prepended trigger row.
• 3335: For large joins, prefer sticking to the user-supplied join order over full enumeration.
  This effectively reverts a change that was introduced in dolthub/go-mysql-server#3289 (potentially by accident). For a large join (16+ tables), full enumeration of every possible join plan is too slow. In the event that we can't find a good join plan heuristically, we should stick to the original join order, and not attempt to enumerate all the possible joins.
  This results in worse joins in the IMDB query tests... but those tests were previously skipped because they were too slow, and we can now unskip them.
  Ideally we would do a better job of finding the best join without needing to fall back on an exhaustive search, but in the meantime, this serves as a workaround.
• 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: dolthub/doltgresql#2093
• 3330: Add fast path for simple IN filters
  If we are filtering an indexed column with a simple IN query, we can avoid building a range tree.
  This currently only applies to integer columns, but it's possible to expand it to floats and decimals.
  Also, simplifies rounding checks for float/decimal keys on integer indexes.
  Benchmarks:
  #10133 (comment)
• 3303: Explicit Analyzer/Builder Overrides
  Related PRs:
  • dolthub/doltgresql#2009
  • #10140

Closed Issues

• 10175: Unable to find field with index ... in row of ... columns
• 7128: Truncate strings when converting to double
• 10156: syntax error in CREATE TEMPORARY TABLE statement used by Gnucash
• 3338: Foreign key behavior doesn't match modern MySQL

Performance

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.

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: dolthub/doltgresql#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: #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 #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 #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: dolthub/doltgresql#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: #10177
• 3331: Introduce notion of conditional equivalence sets in FDS for optimizing outer joins.
  Fixes #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 (dolthub/go-mysql-server#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

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: #10136: Fix dolt_backup to work in non-Dolt directories
  Fixes #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: #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

Performance

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 #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 #10102
  fixes #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 #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: #10150 (comment)
• 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

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: #10138: Fix dolt_backup sync and sync-url not taking working set changes in transaction
  Fixes #10138
• 10146: #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: #10150 (comment)
• 3321: rewrite last query info
  Reimplement LastQueryInfo to not use a map of *atomic.Value with constant keys
  benchmarks: #10148 (comment)
• 3319: Fix TimestampFuncExpr and SetOp in stored procedures
  Changes:
  • add missing case for replacing variables for TimestampFuncExpr in the interpreter
  • fix incorrect interface cast when assigning to ast.Subquery.Select
    Fixes:
  • #10141
  • #10142
• 3318: #10113: Fix DELETE queries with NOT EXISTS uninitialized subqueries
  Fixes #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

Merged PRs

dolt

• 10110: #7628: Refactor dolt backup to use SQL interface
  Fixes #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: #10113: Fix DELETE queries with NOT EXISTS uninitialized subqueries
  Fixes #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

Performance

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

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 #10008
  Doc updates dolthub/docs#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: #10119 (comment)
• 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: #10103 (comment)

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

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: #10103 (comment)
• 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: #10101 (comment)
• 3308: make IsNullable return true for nullable datetime functions
  fixes #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

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 #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: #10083: Honor definer privileges when rebinding views
  Fixes #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 #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: #10084

Closed Issues

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