Download Latest Version dolt-windows-amd64.7z (22.4 MB)
Email in envelope

Get an email when there's a new version of Dolt

Home / v1.83.1
Name Modified Size InfoDownloads / Week
Parent folder
dolt-windows-amd64.msi 2026-03-03 45.0 MB
0
dolt-1.83.1-1.aarch64.rpm 2026-03-03 40.5 MB
0
dolt-1.83.1-1.x86_64.rpm 2026-03-03 43.6 MB
0
install.sh 2026-03-03 3.2 kB
0
dolt-windows-amd64.7z 2026-03-03 22.5 MB
0
dolt-windows-amd64.zip 2026-03-03 39.4 MB
0
dolt-darwin-arm64.tar.gz 2026-03-03 40.5 MB
0
dolt-darwin-amd64.tar.gz 2026-03-03 42.9 MB
0
dolt-linux-arm64.tar.gz 2026-03-03 40.5 MB
0
dolt-linux-amd64.tar.gz 2026-03-03 43.6 MB
0
1.83.1 source code.tar.gz 2026-03-03 12.0 MB
0
1.83.1 source code.zip 2026-03-03 13.8 MB
0
README.md 2026-03-03 133.8 kB
0
Totals: 13 Items   384.5 MB 0

Merged PRs

dolt

  • 10611: Fix Parquet table import -u to skip missing table columns and match CSV warning behavior Fix [#10589]
  • Parquet dolt table import -u no longer fails immediately when the destination table has additional columns missing from the file.
  • Missing destination columns now produce the standard schema mismatch warning path for Parquet.
  • 10597: go/store: fix push latency growth for git-backed remotes Cache remote DoltDB instances across pushes, use parented commits with bounded depth for incremental git deltas, write table files as single blobs instead of split .records/.tail intermediates, and run periodic git gc to repack cache repos.
  • 10590: Fix nil pointer panic in workspace table Update and Delete methods When StatementBegin encounters an error (e.g., table not found in staging root), it stores the error in wtu.err but leaves tableWriter as nil. The Update and Delete methods were dereferencing tableWriter before checking if it was nil, causing a panic. This fix adds an early return to check for errors from StatementBegin before attempting to use tableWriter, preventing the nil pointer dereference.

go-mysql-server

  • 3449: keep top-level plan.Limit for doltgres generate_series PR https://github.com/dolthub/go-mysql-server/pull/3432 replaced plan.Limit nodes with plan.TopN, because they are unnecessary for anything in dolt and gms. However, because of the way generate_series works with LIMIT, we actually need to keep the plan.Limit at the top. This should have minimal impact on performance
  • 3448: Move / guard on new databases to Dolt and add sql.ErrWrongDBName and sql.SQLError to automatically add other error metadata Parent [#10431]
  • 3447: Handle Decimal types in greatest and least functions fixes [#10562]
  • 3442: sql/types: implement NumberType for system numeric types ## Summary
  • Implement sql.NumberType for system numeric system-variable types:
  • SystemBoolType
  • systemIntType
  • systemUintType
  • systemDoubleType
  • Add compile-time interface conformance checks for these types.
  • Add tests to verify:
  • sql.IsNumberType recognizes system numeric types.
  • stats join alignment accepts system numeric types (AlignBuckets path). ## Testing
  • go test ./sql/types ./sql/stats
  • go test ./sql/... -run TestDoesNotExist -tags=gms_pure_go ## Related
  • Relates to [#10535]
  • 3441: bug fix: allow ALTER TABLE DROP CONSTRAINT to remove unique indexes When adding a unique constraint to a table, it wasn't possible to remove it using ALTER TABLE DROP CONSTRAINT. This change allows unique indexes to be removed with this syntax. Related to: https://github.com/dolthub/doltgresql/pull/2359
  • 3438: Implement sql.StringType interface for systemStringType fixes [#10534] part of [#10535]
  • 3436: Get index column name using offset from table name prefix length fixes [#10527] Using the index of the first found . rune as an offset to get an index column name was causing column names to not be correctly matched when the table name contained periods. Using the length of the table name as an offset avoids this issue and is also slightly more performant.
  • 3434: /_integration/php: fix cve
  • 3433: Correctly compute scopeLen for joins In a join node, the scopeLen variable is the total number of columns that represent values from outer scopes. Previously, we set this value equal to the number of columns in the immediate parent scope. When there are multiple nested scopes, this value is incorrect. This PR adds an example of when this matters: a non-lateral join in multiple nested scopes would return an incorrect number of columns. A projection above this join would then index into this returned row, resulting in an out-of-bounds error.
  • 3432: TopN optimizations Changes:
  • Replace LIMIT(PROJECT(SORT(...))) with PROJECT(TOPN(...))
  • When TopN(Limit = 1), use topRowIter to avoid interface conversions and extra mallocs. Benchmarks: https://github.com/dolthub/dolt/pull/10522#issuecomment-3937563308
  • 3429: Disallow creating VECTOR indexes on nullable columns Vector indexes require NOT NULL columns, similar to spatial indexes. Previously, creating a vector index on a nullable column was silently accepted, which could cause runtime panics if any of the elements were NULL. This adds validation in both the analyzer (CREATE TABLE) and DDL execution (CREATE INDEX / ALTER TABLE) paths, returning a clear error message.
  • 3428: Refactor how we manage outer scopes in join iteration There were several problems with the previous join iterator implementation:
  • Each type of iterator was implemented separately, even though 90% of the logic was identical. But slight variations in how they were written led to bugs that only existed in some but not others.
  • The merge join iterator and the full outer join iterator did not correctly handle joins within subqueries.
  • Some iterators would not always close child iterators. The behavior with subqueries is the main motivation for this PR. Previously, in order to expose values from outer scopes to iterators, we would dynamically inject PrependNodes into subquery build plans. These nodes would insert values into the beginning of returned rows, allowing parent iterators to read them and use them in expressions. To compensate for this, we would also inject StripRowNodes into joins. StripRowNodes are the opposite of PrependNodes, removing columns from their iterators. This logic was incredibly difficult to reason about correctly:
  • Injecting values from the outer scope this way inherently complicates iterator logic, particularly for joins.
  • StripRowNodes were inserted prior to plan execution (during the assignExecIndexes pass), while PrependNodes were inserted dynamically during plan execution. Both parts of the code had to agree on how many values were being inserted/removed, which required two different packages to understand each other's inner logic. Changes to one would require changes to the other to prevent subtle bugs.
  • The current implementation had several bugs in the case of multiple nested scopes: -- Lateral joins would re-include all the values from the outermost scope in the next scope, effectively doubling the number of columns with each nesting level. -- StripRowNodes would only be generated based on the innermost scope, resulting in some injected values not being removed. -- StripRowNodes would be generated under each join node, including between join nodes in a multi-table join. Join nodes would thus would need to re-insert these values in order to compensate... but were expected to not re-insert columns corresponding to values defined by a parent join node, except for lateral joins... reasoning about this correctly quickly becomes untenable. Ultimately, there's no reason why join nodes can't handle this directly. And removing the StripRowNodes type and replacing it with logic in the join iterators actually makes the logic much more consistent: Parent iterators should assume that all child iterators contain prepended values for outer scopes, and values determined by the node's schema, and nothing else. And the parent iterator returns rows that also have this property.
  • 3427: Do not wrap hoisted subquery in Limit node until AFTER checking if it's a SubqueryAlias Wrapping subquery nodes in a Limit node before checking if it was a SubqueryAlias was causing us to not find SubqueryAlias nodes. This was noticed when investigating [#10472]. We should probably be inspecting the whole node instead of simply checking the node type, but this is a quick fix. filed [#10494] to add better test coverage and address TODOs
  • 3426: Do not push filters into SubqueryAliases that wrap RecursiveCTEs fixes [#10472] All RecursiveCTEs are wrapped by a SubqueryAlias node. We currently don't push filters through a RecursiveCTE so pushing the filter below the SubqueryAlias just causes it to be awkwardly sandwiched in between and might make some queries less optimal if the filter contains outerscope columns since the SQA gets marked as uncacheable. We probably can push filters through a RecursiveCTE in some cases, but we should spend more time thinking about what that means (see [#10490]). Also contains some refactors that I noticed along the way. skipped tests will be fixed in [#3427]
  • 3425: Do not set scope length during join planning related to [#10472] Scope length should only be set when assigning indexes if the scope length then is not zero. The scope length set during join planning is doesn't actually refer to the correct scope length, and if it was actually supposed to be zero, it was never correct set back to zero, causing a panic.
  • 3423: Do not allow sort-based joins between text and number type columns fixes [#10435] Disables merge and range heap joins between text and number type columns
  • 3419: Use placeholder ColumnIds for EmptyTable Fixes [#10434] EmptyTable implements TableIdNode so it was using Columns() to get the ColumnIds. EmptyTable.WithColumns() is only ever called for testing purposes; as a result, the ColSet returned is empty. This causes the column to ColumnId mapping to be incorrectly off set, leading to the wrong index id assigned. This fix adds a case for EmptyTable in columnIdsForNode to add placeholder ColumnId values so the mappings are correctly aligned. I considered setting the actual ColSet for EmptyTable but there's actually not a good way to do that. Regardless, the index id will be set either using the name of the column or using the Projector node that wraps the EmptyTable. Similar to SetOp, EmptyTable probably shouldn't be a TableIdNode (see [#10443])
  • 3417: Do not join remaining tables with CrossJoins during buildSingleLookupPlan fixes [#10304] Despite what the comment said, it's not safe to join remaining tables with CrossJoins during buildSingleLookupPlan. It is only safe to do so if every filter has been successfully matched to currentlyJoinedTables. Otherwise, we end up dropping filters. For example, we could have a query like select from A, B, inner join C on B.c0 <=> C.c0 where table A has a primary key and tables B and C are keyless. columnKey matches A's primary key column and A would be added to currentlyJoinedTables. Since the only filter references B and C and neither are part of currentlyJoinedTabes, nothing is ever added to joinCandidates. However, it's unsafe to join all the tables with CrossJoins because we still need to account for the filter on B and C.
  • 3416: allow Doltgres to add more information schema tables
  • 3415: Simplify Between expressions for GetField arguments fixes [#10284] part of [#10340] benchmarks
  • 3410: Replace Time.Sub call in TIMESTAMPDIFF with microsecondsDiff fixes [#10397] Time.Sub doesn't work for times with a difference greater than 9,223,372,036,854,775,807 (2^63 - 1) nanoseconds, or ~292.47 years. This is because Time.Sub returns a Duration, which is really an int64 representing nanoseconds. MySQL only stores time precision to the microsecond so we actually don't care about the difference in nanoseconds. However, there's no easy way to directly expose the number of microseconds or seconds since epoch using the public functions for Time -- this is because seconds since epoch are encoded differently with different epochs depending on whether the time is monotonic or not (Jan 1, 1885 UTC or Jan 1, 0001 UTC). Time.Sub uses Time.sec to normalize Time objects to seconds since the Jan 1, 0001 UTC epoch. But Time.sec isn't public so we can't call it ourselves. And Time.Second and Time.Nanosecond only give the second and nanosecond portion of a wall time, not the seconds/nanoseconds since an epoch. However, Time.UnixMicro does give us the microseconds since Unix epoch (January 1, 1970 UTC)...by calling Time.sec and then converting that to Unix time. So microsecondsDiff calculates the difference in microseconds between two Time objects, getting their microsecond values by calling Time.UnixMicro on both of them. This isn't the most efficient but it's the best we can do with public functions.
  • 3409: Calculate month and quarter for timestampdiff based on date and clock time values fixes [#10393] Refactors logic for year into separate function monthDiff so that it can be reused for month and quarter
  • 3408: Added runner to hooks This adds a sql.StatementRunner to all hooks, as they may want to execute logic depending on the hook statement. For example, cascade table deletions could literally just run DROP on the cascading items when dropping a table rather than trying to manually craft nodes which are subject to change over time.
  • 3407: Calculate year for timestampdiff based on date and clock time values fixes [#10390] Previous calculation incorrectly assumed every year has 365 days (doesn't account for leap years) and month has 30 days (doesn't account for over half the months). The offset from this wasn't noticeable with smaller time differences but became apparent with larger time differences. This still needs to be fixed for month and quarter (#10393)
  • 3406: Set table names to lower when creating table map fixes [#10385]
  • 3404: Bump google.golang.org/protobuf from 1.28.1 to 1.33.0 Bumps google.golang.org/protobuf from 1.28.1 to 1.33.0. Dependabot compatibility score Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/dolthub/go-mysql-server/network/alerts).
  • 3403: /go.{mod,sum}: bump go version
  • 3400: Allow pushing filters past Project nodes The analyzer tries to improve query plans by moving filter expressions to be directly above the table that they reference. Previously, this had a limitation in that it would treat references to aliases in Project nodes as opaque: if the alias expression references a table, the analysis wouldn't consider the filter to reference that table. As a result, it wasn't possible to push a filter into multiple subqueries unless a previous optimization eliminated the Project node. This PR enhances the analysis with the following steps:
  • Every alias on a Project node has a unique column id, so we walk the plan tree to build a map from Project column ids to the underlying expressions.
  • When computing which filter expressions can be pushed to which tables, we normalize the filter expressions by replacing GetFields on a Project with the underlying expression.
  • When pushing a Filter above a table or into a subquery, we also replace GetFields on a Project with the underlying expression. Reasoning about the safety is tricky here. We should replace a GetField with the underlying expression if and only if we're actually moving the Filter beneath the Project. The main concerns would be:
  • If a join plan has two Project nodes without an opaque node (like a SubqueryAlias) between them, then a Filter might only get pushed beneath one Project, but references to both Projects in the filter expression could get unwrapped.
  • If a join plan has a Project node in one child, and a Table in the other, then a filter expression could get pushed to be above the Table even if it references the Project In practice I don't think the first concern can happen because it would require that the filter is getting pushed to some nameable-but-not-opaque node between the Projects, which I don't think exists. The second concern requires that the project aliases an expression that doesn't reference any tables but can't be replaced with its underlying expression in a filter, and I don't think that's possible either.
  • 3399: GMS warning on functional indices Makes it so create index queries with expression argument will produce a warning instead of an error.
  • 3396: avoid converting float64 to float64 We save on conversion costs by avoiding a call to convert float64 to float64. Unfortunately this has little to no impact on any of our benchmarks because groupbyIter uses concurrency. benchmarks: https://github.com/dolthub/dolt/pull/10359#issuecomment-3787735021
  • 3395: fewer strings.ToLower calls in gatherTableAlias benchmarks: https://github.com/dolthub/dolt/pull/10355#issuecomment-3787079045
  • 3393: add transform.InspectWithOpaque function This changes transform.Inspect to not apply the helper function on children of sql.OpaqueNodes. Additionally, it adds a transform.InspectWithOpaque that does. This is to match transform.Node and transform.NodeWithOpaque. There are still some inconsistencies between the different transform helper functions:
  • transform.Node:
  • post order (applies to node.Children then node)
  • no way to break out early
  • transform.Inspect:
  • pre order (applies to node then node.Children)
  • can break out early (only on all or none of children)
  • return true to continue
  • transform.InspectExpr:
  • post order (applies to expr.Children then expr)
  • can break out early, including stopping during children
  • return false to continue
  • 3389: remove convertLeftAndRight This PR removes c.convertLeftAndRight, which avoids calls to c.Left().Type() and c.Right().Type(). Not entirely sure why receiver methods would impact performance this much, but benchmarks say so. Benchmarks: https://github.com/dolthub/dolt/pull/10342#issuecomment-3775801225
  • 3388: Apply filter simplifications to Join condition part of [#10284] part of [#10335]
  • 3387: add TODOs and update simplified Not type (wasn't expecting this branch to merge)
  • 3386: Push filters that contain references to outer/lateral scopes. We attempt to push filter expressions deeper into the tree so that they can reduce the size of intermediate iterators. Ideally, we want to push filters to directly above the data source that they reference. Previously, we only pushed filters if they only referenced a single table, since pushing a filter that referenced multiple tables could potentially move the filter to a location where one of the referenced tables is no longer in scope. However, if the extra table references refer to a table in an outer scope or lateral scope, pushing the filter is completely safe. GetFields that reference an outer or lateral scope can be effectively treated as literals for the purpose of this optimization. This PR changes getFiltersByTable, a function that maps tables onto the filters that reference those tables. Previously it would ignore filters that reference multiple tables. Now, it allows those filters provided that the extra references are to outer/lateral scopes. This improves many of the plan tests:
  • The changed test in tpch_plans.go pushes a filter into the leftmost table lookup
  • The second changed test in query_plans.go replaces a naive InnerJoin with a CrossHashjoin
  • integration_plans.go shows many queries that now have an IndexedTableAccess instead of a table scan, or where we push a filter deeper into a join. A small number of neutral / slightly negative changes:
  • One of the changes in integration_plans.go introduces a redundant filter that was previously being removed. In practice this is pretty benign because filters rarely impact the runtime unless they require type conversions.
  • The first changed test in query_plans.go replaces a LookupJoin with a LateralCrossJoin on an IndexedTableAccess. These two plans are effectively equivalent, but the LateralCrossJoin is harder to analyze, has a larger estimated cost and larger row estimate, and could in theory inhibit subsequent optimizations. I imagine we could create a new analysis pass that converts this kind of LateralCrossJoin into a LookupJoin.
  • 3384: Look at every join node parent when computing outer scopes. Previously, when building scopes for subqueries that appear inside joins, we would only track a single parent join node. If the subquery had multiple join parents, we would only be able to resolve references to the innermost subquery. This inhibits the optimizations we can perform. This PR uses a custom tree walker to track a list of parent join nodes, and includes an example of a query that was not previously possible to optimize.
  • 3383: When applying indexes from outer scopes, resolve references to table aliases The previous implementation of the applyIndexesFromOuterScopes optimization uses the getTablesByName function to map table name references onto tables. But this function only locates ResolvedTables, and other optimizations rely on this behavior. I've split getTablesByName into two different functions: getResolvedTablesByName, which has the original behavior, and getNamedChildren, which takes a parent node and identifies all nameable nodes in its children, including both ResolvedTables and TableAliases.
  • 3382: Ensure join correctness for enums of different types fixes [#10311] branched from [#3381] Enums of different types join based on their string value, not their underlying int value. Ensures join correctness for enums of different types by doing the following:
  • use type-aware conversion with enum origin types to properly convert enums to their string values
  • disable Lookup joins for enums of different types. Lookup joins should not work here because enums are indexed based on their int values.
  • disable Merge joins for enums of different types. Merge joins should not work here because enums are sorted based on their int values.
  • 3381: Use key type for memory table index filter range part of [#10311] This change allows avoiding unnecessary type conversions when filtering by index and also simplifies some range filter expressions. This causes foreign keys, particularly enums and sets, to be compared based on their internal values, instead of based on the generalized converted type.
  • 3380: Generate index lookups for filters that appear in lateral joins This PR enhances the "applyIndexesFromOuterScope" analysis pass to transform filters on tablescans into indexed table lookups, when the table's column is being compared with a column visible from a lateral join. An example of a query that can be optimized with this change: select x, u from xy, lateral (select * from uv where y = u) uv; Users don't often write lateral joins, but the engine can transform WHERE EXISTS expressions into lateral joins, and this lets us optimize those too.
  • 3379: Create scope mapping for views This is a partial fix for dolthub/dolt/issues/10297 When parsing a subquery alias, we create a new column id for each column in the SQA schema. The scope mapping is a dictionary on the SQA node that maps those column ids onto the expressions within the subquery that determine their values, and is used in some optimizations. For example, in order to push a filter into a subquery, we need to use the scope mapping to replace any GetFields that were pointing to the SQA with the expressions those fields map to. If for whatever reason the SQA doesn't have a scope mapping, we can't perform that optimization. We parse views by recursively calling the parser on the view definition. This works but it means that the original parser doesn't have any references to the expressions inside the view, which prevents us from creating the scope mapping. This PR attempts to fix this. Instead of defining the SQA columns in the original parser (where we no longer have access to the view's scope), we now create the columns while parsing the view, and attach them to the scope object for the view definition. Then we store that scope in a field on the Builder, so that the original parser can copy them into its own scope. This feels hacky, but was the best way I could think of to generate the scope mappings and ensure they're visible outside the view.
  • 3376: Add IsExpr case to replaceVariablesInExpr Stored procedures containing IS expressions that referenced a procedure variable were breaking.
  • 3371: Error out for NATURAL FULL JOIN Fixes [#10268] Part of [#10295] Relies on dolthub/vitess#447 and adds test
  • 3370: Wrap errgroup.Group.Go() calls for consistent panic recovery Each spawned goroutine needs a panic recovery handler to prevent an unexpected panic from crashing the entire Go process. This change introduces a helper function that wraps goroutine creation through errgroup.Group and installs a panic recovery handler and updates existing code to use it.
  • 3369: Added DISTINCT ON handling Related PRs:
  • https://github.com/dolthub/vitess/pull/446
  • https://github.com/dolthub/doltgresql/pull/2181
  • 3368: Do not parse trigger bodies in LoadOnly context fixes [#10287] fixes [#10288] This PR adds a LoadOnly flag to a trigger context so that the body of a CreateTrigger statement is not unnecessarily parsed. This avoids parsing the trigger body every time an insert, update, or delete is called and only parses it when the trigger is actually relevant to the event. This also avoids parsing the trigger body when show trigger is called. This PR also rearranges some things in buildCreateTrigger to be more performant.
  • 3367: drop schema support
  • 3366: Fix query ok for drop view fixes [#10201]
  • 3365: Handle more types in abs fixes [#10171] fixes [#10270] Add case for bool types and add default case that tries to convert value to Float64.
  • 3364: Add panic handling to spawned goroutine Spawning a new go routine prevented Doltgres' panic handler from catching the panic. This was discovered by Doltgres regression tests crashing from the unhandled panic.
  • 3361: Handle empty right iterators in exists iterator as an EOF fixes [#10258] An empty right iterator in an exists iterator should be treated the same as an EOF. Previously, we were treating an empty right iterator as if it would be returning a single nil row, but this is wrong. An empty right iterator would imply an empty set, which is not the same as a single nil row.
  • 3358: condense time.Time library calls Instead of calling Year(), Month(), Day(), Hours(), Minutes(), and Seconds() individually, just use time.Date() and time.Clock(). Benchmarks: https://github.com/dolthub/dolt/pull/10249#issuecomment-3698038879
  • 3356: Return boolean literal when simplifying AND and OR filters fixes [#10243] Previously, if one of the children of an AND or OR expression was a literal that evaluated to false or true (respectively), we would return the child. However, this caused a typing issue since AND and OR are booleans while its children can be of any type. Take the expression 19 or 's' for example; the left child 19 evaluates to true, making the expression true every time, but returning the left child 19 as a simplification would be incorrect since we would want the expression to simplify to a boolean true, not the number 19. Now, instead of returning the child that determines the result of an AND or OR expression, we return the boolean value that the expression results to.
  • 3355: Do not use nullable columns as null filter when converting antijoins to left joins fixes [#10234] When converting an antijoin to a left join, it is normally okay to use a nullable GetField in a null filter. However, we cannot do so if GetField is both nullable and part of an OR expression. There's currently no way of identifying an expression's parent during InspectExpr so we have to be extra safe by not allowing nullable GetFields in null filters at all.
  • 3354: Add required attribution for mascot image to README This PR adds the required attribution for the mascot image used in the README. The mascot image is based on the Go gopher and related derivative work, and the README has been updated to include the appropriate credits. Please let me know if any adjustments are needed.
  • 3352: Use concurrency in groupby compute Splits up the compute in groupByGroupingIter into two threads:
  • That reads rows off disk into a sql.Row buffer
  • That processes each row and updates the aggregation buffer Benchmarks: https://github.com/dolthub/dolt/pull/10232#issuecomment-3677075947
  • 3350: Updated IsNullable for all functions to match Eval output fixes [#10161]
  • 3349: Add User Variable discards and fix per-row field to column indices for LOAD DATA LOAD DATA has been ingesting user variable related fields into the rows used to evaluate set expressions. This fix resolves this issue, and as a result adds the feature to use user variables to discard fields from a parsed file line. Default initialization of expressions has also been updated to follow MySQL's "zero value" behavior for non-nullable columns.
  • 3348: avoid heap allocs in transform.Inspect and transform.InspectExpr Changes:
  • transform.Inspect switches on UnaryNode and BinaryNode to avoid heap allocations from node.Children()
  • transform.InspectExpr switches on UnaryExpression and BinaryExpression to avoid heap allocations from expression.Children()
  • remove UnaryExpression implementation from unaryAggBase and some functions that can return multiple children. Benchmarks: https://github.com/dolthub/dolt/pull/10222#issuecomment-3663179491
  • 3347: Customizable filter walk for costed index scan This is to support Doltgres, which has extra nodes in its expression trees in some cases.
  • 3345: various analyzer and planbuilder optimizations Changes:
  • rewrote convertInt to call strings library fewer times
  • use casting to detect rounding in index builder
  • separate code for InspectExpr()
  • simplify isEvaluable into single pass
  • replace more Sprintf with simple string concatenation
  • have iScanAnd count children as they are added benchmarks: https://github.com/dolthub/dolt/pull/10210#issuecomment-3657596361
  • 3343: Check if key is convertible before memoizing lookup join fixes [#10186] Numeric types cannot be used as keys for String type columns due to the way the types convert. For example, a String with a value "i" is equivalent to 0; however, 0 converts to "0" as a String and therefore cannot be used as key to index to "i". Doltgres companion PR dolthub/doltgresql#2121
  • 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 https://github.com/dolthub/go-mysql-server/issues/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.
  • 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
  • 3335: For large joins, prefer sticking to the user-supplied join order over full enumeration. This effectively reverts a change that was introduced in https://github.com/dolthub/go-mysql-server/pull/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: 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: sql 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.
  • 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: https://github.com/dolthub/dolt/pull/10133#issuecomment-3618780244
  • 3329: Bump github.com/sirupsen/logrus from 1.8.1 to 1.8.3 Bumps github.com/sirupsen/logrus from 1.8.1 to 1.8.3.
    Release notes

    Sourced from github.com/sirupsen/logrus's releases.

    v1.8.3

    What's Changed

    New Contributors

    Full Changelog: https://github.com/sirupsen/logrus/compare/v1.8.2...v1.8.3

    v1.8.2

    What's Changed

    New Contributors

    Full Changelog: https://github.com/sirupsen/logrus/compare/v1.8.1...v1.8.2

Commits


Dependabot compatibility score You can trigger a rebase of this PR by commenting @dependabot rebase.

Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/dolthub/go-mysql-server/network/alerts).

Note Automatic rebases have been disabled on this pull request as it has been open for over 30 days. * 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 [#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: 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 * 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. * 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: - https://github.com/dolthub/dolt/issues/10141 - https://github.com/dolthub/dolt/issues/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. * 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. * 3311: Bump golang.org/x/crypto from 0.0.0-20191011191535-87dc89f01550 to 0.45.0 Bumps golang.org/x/crypto from 0.0.0-20191011191535-87dc89f01550 to 0.45.0.

Commits


Dependabot compatibility score Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/dolthub/go-mysql-server/network/alerts).
  • 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 [#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]
  • 3304: Support table functions with non-literal arguments in subqueries and lateral joins This PR fixes several issues that prevent table functions from evaluating correctly when they take non-literal arguments and appear in subqueries or lateral joins.
  • [8a5f58] fixes a problem where references to an outer scope that appear in the topmost scope of a subquery won't cause the subquery to be marked as containing out-of-scope references.
  • This caused the subquery to be seen as cacheable even though it isn't, which could cause incorrect query results
  • This also caused the analyzer to incorrectly generate a CrossJoin instead of a LateralCrossJoin, which would then cause the join planner to commute the join children even though it was not safe to do so. This would ultimately cause an out-of-bounds field access while building the table function.
  • [0147ad] fixes two other issues where join planning would drop the Lateral marker during join planning, resulting in generating a CrossJoin instead of a LateralCrossJoin
  • [0e2b6d] fixes an oversight in the LateralCrossJoin RowIter that was causing rows from the parent and left scopes to not be passed into the right child All three of these changes are required together in order to properly evaluate the newly added test queries.
  • 3303: Explicit Analyzer/Builder Overrides Related PRs:
  • https://github.com/dolthub/doltgresql/pull/2009
  • https://github.com/dolthub/dolt/pull/10140
  • 3302: Wrap nullable hoisted filter in IsTrue fixes [#10070] Filters that evaluate to null in an EXISTS or IN subquery context should be treated the same as false. When hoisted out of the subquery, nullable filters need to be wrapped in an IsTrue expression to ensure that they are still treated the same as false when they evaluate to null. Not doing so was causing a bug where rows were being dropped from NOT EXISTS if the filter evaluated to null. Since the filter expression was evaluated to null, the NOT expression wrapping it would evaluate to null as well. This caused the filter iterator to reject the row because it did not evaluate to true. Wrapping the filter expression with IsTrue ensures that nulls are then evaluated to false, which will then evaluate to true with NOT.
  • 3300: Move hoistOutOfScopeFilters rule to DefaultRules fixes [#10064] hoistOutOfScopeFilters was not running as part of finalizeUnions, causing us to not correctly analyze queries that were parts of unions
  • 3299: Prevent panic when using table functions in joins and subqueries This prevents the panic seen in https://github.com/dolthub/dolt/issues/10051 The join planner assumed that every instance of TableAlias wrapped an implementer of sql.TableNode. Only tables that support lookups implement sql.TableNode. Table functions that are not backed by an actual table and don't support lookups do not implement this interface. This panic is happening when testing to see whether we can optimize a join into a RightSemiJoin. The table needs to support lookups for this optimization to be allowed. So if it doesn't implement sql.TableNode, it suffices to skip this join plan, since we wouldn't be able to produce it away. This does not fix the broader issue of https://github.com/dolthub/dolt/issues/10051, which is that it is currently impossible for table functions that accept non-literal arguments to support efficient lookups. I'm not currently aware of any use cases where this is required, but I'll keep the issue open to track it in case we need to support that in the future.
  • 3298: Validate connection security properties Extends authentication handlers to validate additional connection properties (e.g. SSL, X509 client cert, cert issuer, cert subject) when additional connection constraints have been configured for a user. Note: tests for this functionality are in https://github.com/dolthub/dolt/pull/10067 Related to https://github.com/dolthub/dolt/issues/10008
  • 3297: [#10050]: Fix JSON conversion for dolt when using TextStorage Fix [#10050]
  • Extended JsonType.Convert to unwrap sql.StringWrapper values before decoding.
  • Add convertJSONValue to handle string and []byte like inputs.
  • 3296: use type switch instead of Fprintf for grouping key FPrintf is slow; it's quicker to use strconv for ints/floats + hash.WriteString and Sprintf + hash.WriteString for all other types. benchmarks: https://github.com/dolthub/dolt/pull/10054#issuecomment-3518575696
  • 3293: Don't make string unless in Debug mode Even though this isn't getting logged anywhere, generating the DebugString for CostedIndexScans is costly enough to show in the profiler. Also specify capacity for rows in Result. benchmarks: https://github.com/dolthub/dolt/pull/10039#issuecomment-3499431486
  • 3292: Updating auth interfaces to pass connection Allows implementations of PlainTextStorage, CachedStorage, and HashStorage to receive the connection, so that they can check connection properties, such as SSL/TLS. Depends on: https://github.com/dolthub/vitess/pull/443/files Related to: https://github.com/dolthub/dolt/issues/10008
  • 3291: Add support for configuring a user's TLS connection requirements Adds support for creating users with TLS connection requirements, and displaying those settings via the mysql.user system table. MySQL documentation on CREATE USER SSL/TLS options Example: CREATE USER user1@localhost REQUIRES X509; Related to https://github.com/dolthub/dolt/issues/10008
  • 3284: Use IndexedTableAccess for Sorts over a SubqueryAlias
  • 3283: [#9316]: Fix PK setting and add new fields for CREATE TABLE ... SELECT Fixes [#9316]
  • 3282: /.github/workflows/bump-dependency.yaml: sanatize stuff
  • 3280: Allow string truncation when casting to date
  • 3279: [#9887]: Add BINLOG and mariadb-binlog support Fixes [#9887]
  • Add BinlogConsumer and BinlogConsumerCatalog interfaces.
  • Add BINLOG statement that decodes base64 encoded event strings and runs them on dolt's binlog replica applier using BinlogConsumer interface.
  • Add support for mariadb-binlog utility with new format support for sql_mode, collation_database, collation_connection, and collation_server, which can use bitmasks and IDs tied to system variable values.
  • Add new format int support for lc_time_names; this remains a no-op.
  • Add authentication handler for Binlog statement and new privilege types binlog_admin, replication_applier.
  • Other system variables have been added as no-ops for mariadb-binlog compatibility: skip_parallel_replication, gtid_domain_id, gtid_seq_no, check_constraint_checks, sql_if_exists, system_versioning_insert_history, and insert_id.
  • Add separate MariaDB-specific system variables array and a new getter that pulls from both system variable arrays.
  • 3278: Respect precision when casting to datetime Also explicitly cast datetime to max precision during comparisons
  • fixes broken ld tests (dolthub/ld#21555)
  • 3277: [#9984]: Fix nil dereference by Dispose() in GROUP BY iterator when Next() is never called Fixes [#9984]
  • 3276: Truncate strings for datetime conversion fixes [#9917]
  • 3275: [#9977]: Prevent filter pushdown for Anti joins for NOT IN Fixes [#9977] Companion [#9979]
  • 3274: Do not convert full outer joins to cross joins fixes [#9973]
  • 3270: [#9969]: Fix ENCLOSED BY ignoring terminator inside of field when using LOAD DATA INFILE Fixes [#9969]
  • 3269: Add Grafana to listed Backends
  • 3267: Fix GroupBy validation for queries with Having fixes [#9963] In [#3166], I had skipped adding aggregate function dependencies to the from scope of the Having node because they were being included in the select expressions during GroupBy validation. However, removing them caused other scoping issue. So I undid the skip, and instead of using the select expressions from the innermost Project node, we now use the select expressions from the innermost Project node that is not a direct child of a Having node. This exposed a bug where we were not able to resolve aliases in OrderBy expressions so I added Alias expressions to the select dependency map used for resolving OrderBy and Select expressions
  • 3265: Do not allow inserting NaN and Inf values into numeric type columns fixes [#3264]
  • 3263: Do not prune tables in semi-joins Fixes [#9951]
  • 3262: [#9927]: Fix SQL regression on UnaryMinus NULL CAST Fixes [#9927]
  • 3261: Do not convert keys if key type is incompatible with column type fixes [#9936] fixes [#7372] makes progress on [#9739]
  • 3260: dolthub/go-mysql-server#3259: Fix system variable lookup to only happen on no qualifier Fixes dolthub/go-mysql-server#3259
  • 3258: [#9935]: Add fix for boolean evaluation in analyzer for EXISTS Fixes [#9935]
  • 3256: [#9927]: Fix double negation overflow with Literals Fixes [#9927] Fixes [#9053]
  • 3252: Add pure Go regex implementation for non-CGO builds This PR provides an optional pure Go regex engine that allows building go-mysql-server without CGO. The default build process (using ICU via CGO) remains unchanged. ## Implementation
  • With CGO (default): Uses the existing go-icu-regex library. (internal/regex/regex_cgo.go)
  • Without CGO (CGO_ENABLED=0 or -tags=gms_pure_go): Uses a new implementation based on Go's standard regexp package. (internal/regex/regex_pure.go) Build selection is handled via Go build tags. ## Compatibility Notes The pure Go engine trades compatibility for portability, as it is based on standard regexp package. Notable limitations compared to ICU include:
  • Lack of back-references
  • No before/after text matching
  • Differences in handling CR ('\r')
  • Other minor differences This change allows running the server in pure Go for users who can accept the trade-offs, providing greater build flexibility.
  • 3251: Condense nested select * from SubqueryAliases into the innermost SubqueryAlias
  • 3250: Replace SubqueryAlias that selects an entire table with TableAlias
  • 3249: [#9916]: Add TRUNCATE(X,D) Support Fixes [#9916] Companion dolthub/docs#2688
  • 3248: Implement sql.ValueRow sql.ValueRow is the reincarnation of sql.Row2. This is an optimization to the sqlengine that eliminates interface boxing by never placing variables into a []interface. sql.ValueRowIter is implemented by:
  • TransactionCommittingIter
  • TrackedRowIter
  • TableRowIter
  • FilterIter Comparison should only use CompareValue when left and right are both NumericType, so Integers, Floats, Decimal, Bit64, and Year types.
  • 3247: [#9865]: Fix EOF on procedure Fixes [#9865]
  • 3246: sql/rowexec: Add a SessionCommandSafepoint session callback for long-running write commands. Call it in some rowexec implementations. This allows for integrators to see quiesced states on engine session utilization even on very long running write operations.
  • 3245: Allow triggers to fire with INSERT...RETURNING statements Fixes [#9895]
  • 3244: /go.{mod,sum}: add patch version
  • 3243: Added armscii charset and collations Adds the armscii charset and both collations
  • Fixes https://github.com/dolthub/dolt/issues/9889
  • 3242: Added collation ignoring for information_schema Provides a fix for:
  • https://github.com/dolthub/dolt/issues/9890
  • 3238: fix load data when escaped and enclosed are the same We weren't actually escaping any characters and just deleting all the escaped characters. fixes: https://github.com/dolthub/dolt/issues/9884
  • 3237: fix string to boolean comparison for HashInTuple expressions fixes: https://github.com/dolthub/dolt/issues/9883
  • 3235: Allow caching subqueries in a tree of joins. This is a follow-up to https://github.com/dolthub/go-mysql-server/pull/3205, catching a previously missed case. In a tree like so: Join A ├─ Table └─ Join B ├─ SubQuery └─ Table We want to be able to cache the subquery result. But we weren't because we saw that the subquery was the leftmost child of a join (Join B) and it doesn't make sense to cache the leftmost child of a join. But really we should consider the subquery to be a child of Join A, where it isn't the leftmost child. That is to say, encountering a join node while we're already walking a join tree shouldn't cause the cacheSubqueryAliasesInJoins to treat it as a new join. This allows for more subquery caching in places that would benefit from it.
  • 3234: [#9873]: Add tests for FOR UPDATE OF Fixes [#9873]
  • 3232: Add TEXT(m) support Fixes [#9872] Companion dolthub/vitess#435
  • 3231: Push filters down into join condition fixes [#9868] doltgres test updated in dolthub/doltgresql#1887
  • 3230: truncation refactoring and partial decimal truncation implementation changes:
  • reorganize more tests
  • fix partition test to truncate with warning
  • fix JSON test to match MySQL's message
  • partially fixes index comparison with type conversion
  • refactor comparison logic for IN operator
  • decimal truncation
  • add warning for negative unsigned cast fixes:
  • https://github.com/dolthub/dolt/issues/7128
  • https://github.com/dolthub/dolt/issues/9735
  • https://github.com/dolthub/dolt/issues/9840 partially addresses: https://github.com/dolthub/dolt/issues/9739
  • 3227: [#9857]: Add UUID_SHORT() support Fixes [#9857] Companion dolthub/docs#2676
  • 3226: fix Expressions() of TableFunctionWrapper to make the function expression visible
  • 3224: Validate expressions in ORDER BY clause during GROUP BY validation fixes [#9767] update dolt test in [#9853]
  • 3223: README.md: Add notes to the readme indicating cgo dependency.
  • 3220: go.mod: Bump go-icu-regex. Pick up ICU4C Cgo dependency. From this commit, go-mysql-server takes a dependency on Cgo and a dependency on ICU4C. To depend on go-mysql-server CGO must be enabled, a C++ compiler must be available and the ICU4C development libraries must be available to the C++ compiler. On Windows, mingw with pacman -S icu is supported. On macOS, Homebrew installed icu4c works, but only if CGO_CPPFLAGS and CGO_LDFLAGS are set to point to the installed development libraries. On Linux, apt-get install libicu-dev, or similar.
  • 3219: dolthub/go-mysql-server#3216: Fix UNION ALL with NULL BLOB SELECT returning NULL for all vals Fixes [#3216]
  • 3217: Add CREATE DATABASE fall back on CREATE SCHEMA to mirror MySQL Fixes [#9830]
  • 3215: Trim strings before converting to bool fixes [#9821] fixes [#9834]
  • 3214: Implement PIPES_AS_CONCAT mode Fixes [#9791] depends on dolthub/vitess#432
  • 3213: Copy parent row in fullJoinIter Fixes [#9805]
  • 3212: Wrap right side in Distinct when converting semi-joins to inner joins Fixes [#9797] Distinct flag wasn't getting propagated through join replanning so instead, we're explicitly wrapping the right side in a Distinct.
  • 3211: Do not return EOF in existsIter when right iter is empty fixes [#9828] Returning EOF was causing us to terminate the existsIter early Added tests for [#9797]
  • 3210: Copy parent row in lateralJoinIterator.buildRow fixes [#9820] Also rename left and right to primary and secondary to follow the same pattern as other join iterators
  • 3209: Convert values to strings when evaluating bit_length Fixes [#9818]
  • 3208: [#9817] - Fix binary operations return type to be uint64 Fixes [#9817]
  • 3206: fix equality check in buildSingleLookupPlan() A join optimization to generate look up plans was incorrectly being applied to filters that were not simple equalities. This resulted in filters getting dropped and incorrect results. fixes: https://github.com/dolthub/dolt/issues/9803
  • 3205: Relax restriction that was preventing us from caching the result of subqueries. https://github.com/dolthub/go-mysql-server/pull/1470 was supposed to, among other things, add restrictions to when we generate CachedResults nodes to cache subquery results. However, the added check is overly broad, and as a result it became impossible to actually cache subquery results. Currently, there is not a single plan test that contains a CachedResults node in the output plan. The cacheSubqueryAliasesInJoins function has a comment: go //The left-most child of a join root is an exception that cannot be cached. No rationale is given for this. Looking at it, it seems like we used to generate CachedResults nodes before we finished resolving references in the query, and now we wait until after. So it's possible that this is the reason for the restriction, and the entire check is no longer necessary. Either way, the implementation is more restrictive than the comment would suggest. Due to how the algorithm tracks state via function parameters, it doesn't propagate state from a child node to it's parents/siblings, and the flag for recording that it's encountered a subqeury gets unset. As a result, no Subqueries will actually be cached. This PR fixes the tree walk to correctly remember once it's encountered a subquery and allow subsequent subqueries to be cached. This is still more broad than the comment would suggest, since it doesn't require that this subquery appear in the left-most child of the join. Among the changed plan tests, we see that CachedResults nodes are now emitted. Most of them are the children of HashLookups, but there are some that are the children of InnerJoin and SemiJoin nodes where one of the things being joined is a subquery.
  • 3204: [#9812]: Coalesce IN and = operator logic Fixes [#9812]
  • 3203: allow setting session variable default value
  • 3201: [#9807] - FULL OUTER JOIN with empty left subquery rets unmatched right rows Fixes [#9807] Fixed fullJoinIter.Next() to use parentRow instead of nil leftRow when building right iter for second phase.
  • 3200: implement double truncation and find correct hash comparison type Changes:
  • Fix HashLookup to find a compatible comparison type to convert left and right values to before hashing. We used to always pick the left type, which led to inconsistencies with MySQL
  • Implement Double value truncation, so incorrect double values are still partially converted to float64. Fixes: https://github.com/dolthub/dolt/issues/9799
  • 3199: Add added column to CreateConstraint scope fixes [#9795]
  • 3197: [#9794] - Fix string function panics with Dolt TextStorage Fixes [#9794]
  • 3196: Do not push down filters for Full Outer joins fixes [#9793] Filters for Full Outer joins should not be evaluated until after tables have been joined.
  • 3195: Initialize newChildren with node.Children to avoid nil child during replaceIdxSort fixes [#9789] continue in JoinNode case was resulting in nil child in newChildren array. This would later cause a panic when child would be referenced.
  • 3194: Group by validation for aggregated queries Fixes [#9761]
  • 3193: Left and right joins should not be optimized into cross joins fixes [#9782]
  • 3192: fix update join with conflicting aliases Update joins with SubqueryAlias with TableAlias matching an outer TableAlias would result in the incorrect table getting picked when resolving Foreign Keys. Fix here is to not Inspect OpaqueNodes to avoid incorrectly overriding any aliases; they shouldn't be visible anyway.
  • 3191: Use Decimal.String() for key in hashjoin lookups fixes [#9777] Decimals are not hashable so we have to use Decimal.String() as a key instead.
  • 3190: Refactorings to support index scans for pg catalog tables This PR adds new interfaces to allow different expressions types to participate in the standard index costing process, which results in a RangeCollection. Also plumbs additional type info through so that types with a more precise conversion process can participate as well.
  • 3187: Allow aggregate/window functions with match expressions fixes [#6556] Seems like the scoping issue has already been fixed.
  • 3167: Bump go-sql-driver/mysql The current version of go-sql-driver/mysql that we depend on doesn't support the type tag for vector types. Bumping this dependency allows us to send and receive vector types along the wire.
  • 3162: Add support for VECTOR type This PR adds a VECTOR type to GMS. Vectors are arrays of 32-bit floats. It also adds several functions that take vectors as arguments, including converting vectors to and from strings, and functions for computing distances between vectors. Finally, it ensures that vector types work correctly when passed to existing functions (such as BIT_LENGTH, MD5, etc.)
  • 2103: Bump google.golang.org/grpc from 1.53.0 to 1.56.3 Bumps google.golang.org/grpc from 1.53.0 to 1.56.3.
    Release notes

    Sourced from google.golang.org/grpc's releases.

    Release 1.56.3

    Security

    • server: prohibit more than MaxConcurrentStreams handlers from running at once (CVE-2023-44487)

      In addition to this change, applications should ensure they do not leave running tasks behind related to the RPC before returning from method handlers, or should enforce appropriate limits on any such work.

    Release 1.56.2

    Release 1.56.1

    • client: handle empty address lists correctly in addrConn.updateAddrs

    Release 1.56.0

    New Features

    Bug Fixes

    API Changes

    Release 1.55.1

    Release 1.55.0

    Behavior Changes

    ... (truncated)

Commits


Dependabot compatibility score You can trigger a rebase of this PR by commenting @dependabot rebase.

Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/dolthub/go-mysql-server/network/alerts).

Note Automatic rebases have been disabled on this pull request as it has been open for over 30 days.

vitess

Commits


Dependabot compatibility score Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/dolthub/vitess/network/alerts).
  • 451: Bump google.golang.org/protobuf from 1.27.1 to 1.33.0 Bumps google.golang.org/protobuf from 1.27.1 to 1.33.0. Dependabot compatibility score Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself) You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/dolthub/vitess/network/alerts).
  • 450: /go.mod: bump go
  • 449: Nathan/functional index Adds a limited method for parsing indexes on functions. Can now parse queries like create index idx on tbl ((col1 + col2))
  • 448: Move SERIAL type out of numeric type definitions so that unsigned value is not overwritten fixes [#10345] MySQL docs
  • 447: Parse NATURAL FULL JOIN Part of [#10268] Part of [#10295] Any join with the NATURAL prefix that was not a LEFT or LEFT OUTER JOINwas getting parsed as aNATURAL RIGHT JOIN. This PR allows forNATURAL FULL JOINto be parsed correctly and also prevents invalid joins using theNATURAL` prefix from getting parsed.
  • 446: Added DISTINCT ON expressions Related PRs:
  • https://github.com/dolthub/go-mysql-server/pull/3369
  • https://github.com/dolthub/doltgresql/pull/2181
  • 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.
  • 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.
  • 442: Additional tests for SSL requirements on created users
  • 441: [#9316]: Add CREATE TABLE ... AS SELECT support Fixes [#9316] Companion dolthub/go-mysql-server#3283
  • 439: [#9887]: Fix empty executable comments and add BINLOG support and mariadb executable comments Fixes [#9887]
  • Add TypeName() to binlogEvent objects for error message creation on the frontend, i.e. go-mysql-server.
  • Add ERBase64DecodeError = 1575, ERNoFormatDescriptionEventBeforeBinlogStatement = 1609, and EROnlyFDAndRBREventsAllowedInBinlogStatement = 1730 for Binlog statements error handling.
  • Add Binlog statement parser support.
  • Add mariadb executable comment support and fix handling of empty comments, i.e. /*!*/ and /*M!*/.
  • 438: /go.mod: add patch version
  • 437: docker-entrypoint.sh: Add VERSIONING to non-reserved
  • 436: [#9873]: Add support FOR UPDATE OF Fixes [#9873] Companion dolthub/go-mysql-server#3234
  • 435: Add TEXT(m) support Fixes [#9872]
  • 432: Implement PIPES_AS_CONCAT mode parsing Part of [#9791]
  • 431: /go.mod: bump go to 1.24.6
  • 426: Length-encode vector values when sent on the wire. GMS uses Vitess code to encode responses into the MySQL wire format. Testing for this change is in the corresponding GMS PR.

Closed Issues

  • 10600: BUG: UPDATE...WHERE NOT IN (SELECT...LIMIT) crashes with field index out of bounds
  • 10589: Inconsistent table import behaviour between CSV and Parquet when columns missing in flat file
  • 3420: VECTOR INDEX causes batch inserts to fail with NULL embeddings
  • 1621: Missing index for foreign key error
  • 3338: Foreign key behavior doesn't match modern MySQL
  • 3273: how to disable some features?
  • 3221: go-mysql-server can no longer claim to be "pure Go"
  • 3264: Panic When Comparing Decimal against NaN
  • 3259: Panic when column is missing and that column is a system variable
  • 3216: No binary data from UNION ALL
Source: README.md, updated 2026-03-03