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 dolthub/go-mysql-server#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: dolthub/doltgresql#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: #10522 (comment)
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 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-automerge-start)
[//]: # (dependabot-automerge-end)

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 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: #10359 (comment)
3395: fewer strings.ToLower calls in gatherTableAlias
benchmarks: #10355 (comment)
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: #10342 (comment)
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 /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:
- dolthub/vitess#446
- dolthub/doltgresql#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: #10249 (comment)
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:
1. That reads rows off disk into a sql.Row buffer
2. That processes each row and updates the aggregation buffer
  Benchmarks: #10232 (comment)
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: #10222 (comment)
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: #10210 (comment)
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 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.
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
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
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.

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)
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
- Add instructions to use different log levels for local and syslog by @tommyblue in sirupsen/logrus#1372
- This commit fixes a potential denial of service vulnerability in logrus.Writer() that could be triggered by logging text longer than 64kb without newlines. by @ozfive in sirupsen/logrus#1376
- Use text when shows the logrus output by @xieyuschen in sirupsen/logrus#1339
New Contributors
- @tommyblue made their first contribution in sirupsen/logrus#1372
- @ozfive made their first contribution in sirupsen/logrus#1376
- @xieyuschen made their first contribution in sirupsen/logrus#1339
Full Changelog: sirupsen/logrus@v1.8.2...v1.8.3
v1.8.2

What's Changed
- CI: use GitHub Actions by @thaJeztah in sirupsen/logrus#1239
- go.mod: github.com/stretchr/testify v1.7.0 by @thaJeztah in sirupsen/logrus#1246
- Change godoc badge to pkg.go.dev badge by @minizilla in sirupsen/logrus#1249
- Add support for the logger private buffer pool. by @edoger in sirupsen/logrus#1253
- bump golang.org/x/sys depency version by @dgsb in sirupsen/logrus#1280
- Update README.md by @runphp in sirupsen/logrus#1266
- indicates issues as stale automatically by @dgsb in sirupsen/logrus#1281
- ci: add go 1.17 to test matrix by @anajavi in sirupsen/logrus#1277
- reduce the list of cross build target by @dgsb in sirupsen/logrus#1282
- Improve Log methods documentation by @dgsb in sirupsen/logrus#1283
- fix race condition for SetFormatter and SetReportCaller by @rubensayshi in sirupsen/logrus#1263
- bump version of golang.org/x/sys dependency by @nathanejohnson in sirupsen/logrus#1333
- update gopkg.in/yaml.v3 to v3.0.1 by @izhakmo in sirupsen/logrus#1337
- update dependencies by @dgsb in sirupsen/logrus#1343
- Fix data race in hooks.test package by @FrancoisWagner in sirupsen/logrus#1362
New Contributors
- @minizilla made their first contribution in sirupsen/logrus#1249
- @edoger made their first contribution in sirupsen/logrus#1253
- @runphp made their first contribution in sirupsen/logrus#1266
- @anajavi made their first contribution in sirupsen/logrus#1277
- @rubensayshi made their first contribution in sirupsen/logrus#1263
- @nathanejohnson made their first contribution in sirupsen/logrus#1333
- @izhakmo made their first contribution in sirupsen/logrus#1337
- @FrancoisWagner made their first contribution in sirupsen/logrus#1362
Full Changelog: sirupsen/logrus@v1.8.1...v1.8.2
Commits
- b30aa27 Merge pull request #1339 from xieyuschen/patch-1
- 6acd903 Merge pull request #1376 from ozfive/master
- 105e63f Merge pull request #1 from ashmckenzie/ashmckenzie/fix-writer-scanner
- c052ba6 Scan text in 64KB chunks
- e59b167 Merge pull request #1372 from tommyblue/syslog_different_loglevels
- 766cfec This commit fixes a potential denial of service vulnerability in logrus.Write...
- 70234da Add instructions to use different log levels for local and syslog
- a448f82 Merge pull request #1362 from FrancoisWagner/fix-data-race-in-hooks-test-pkg
- ff07b25 Fix data race in hooks.test package
- f8bf765 Merge pull request #1343 from sirupsen/dbd-upd-dep
- Additional commits viewable in compare view
[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=github.com/sirupsen/logrus&package-manager=go_modules&previous-version=1.8.1&new-version=1.8.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) You can trigger a rebase of this PR by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---

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 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 #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)
3321: rewrite last query info
Reimplement LastQueryInfo to not use a map of *atomic.Value with constant keys
benchmarks: #10148 (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.
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.
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.
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
- See full diff in compare view
[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=golang.org/x/crypto&package-manager=go_modules&previous-version=0.0.0-20191011191535-87dc89f01550&new-version=0.45.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) 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-automerge-start) [//]: # (dependabot-automerge-end) ---

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 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: #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.
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.
- 8a5f5821120ca8b5306628cd18ad493f87a28413 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.
- 0147ad3c3e522fa36552944d15adb1425cb22c1c fixes two other issues where join planning would drop the Lateral marker during join planning, resulting in generating a CrossJoin instead of a LateralCrossJoin
- 0e2b6da9d20228a9f3255b2b532f97eae9f34b80 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:
- dolthub/doltgresql#2009
- #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 #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 #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 #10067
Related to #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: #10054 (comment)
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:
#10039 (comment)
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: #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 #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 #9889
3242: Added collation ignoring for information_schema
Provides a fix for:
- #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: #9884
3237: fix string to boolean comparison for HashInTuple expressions
fixes: #9883
3235: Allow caching subqueries in a tree of joins.
This is a follow-up to dolthub/go-mysql-server#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:
- #7128
- #9735
- #9840
  partially addresses: #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: #9803
3205: Relax restriction that was preventing us from caching the result of subqueries.
dolthub/go-mysql-server#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:
```
//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: #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
- status: To fix a panic, status.FromError now returns an error with codes.Unknown when the error implements the GRPCStatus() method, and calling GRPCStatus() returns nil. (#6374)
Release 1.56.1
- client: handle empty address lists correctly in addrConn.updateAddrs
Release 1.56.0

New Features
- client: support channel idleness using WithIdleTimeout dial option (#6263)
  - This feature is currently disabled by default, but will be enabled with a 30 minute default in the future.
- client: when using pickfirst, keep channel state in TRANSIENT_FAILURE until it becomes READY (gRFC A62) (#6306)
- xds: Add support for Custom LB Policies (gRFC A52) (#6224)
- xds: support pick_first Custom LB policy (gRFC A62) (#6314) (#6317)
- client: add support for pickfirst address shuffling (gRFC A62) (#6311)
- xds: Add support for String Matcher Header Matcher in RDS (#6313)
- xds/outlierdetection: Add Channelz Logger to Outlier Detection LB (#6145)
  - Special Thanks: @s-matyukevich
- xds: enable RLS in xDS by default (#6343)
- orca: add support for application_utilization field and missing range checks on several metrics setters
- balancer/weightedroundrobin: add new LB policy for balancing between backends based on their load reports (gRFC A58) (#6241)
- authz: add conversion of json to RBAC Audit Logging config (#6192)
- authz: add support for stdout logger (#6230 and #6298)
- authz: support customizable audit functionality for authorization policy (#6192 #6230 #6298 #6158 #6304 and #6225)
Bug Fixes
- orca: fix a race at startup of out-of-band metric subscriptions that would cause the report interval to request 0 (#6245)
- xds/xdsresource: Fix Outlier Detection Config Handling and correctly set xDS Defaults (#6361)
- xds/outlierdetection: Fix Outlier Detection Config Handling by setting defaults in ParseConfig() (#6361)
API Changes
- orca: allow a ServerMetricsProvider to be passed to the ORCA service and ServerOption (#6223)
Release 1.55.1
- status: To fix a panic, status.FromError now returns an error with codes.Unknown when the error implements the GRPCStatus() method, and calling GRPCStatus() returns nil. (#6374)
Release 1.55.0

Behavior Changes
- xds: enable federation support by default (#6151)
- status: status.Code and status.FromError handle wrapped errors (#6031 and #6150)
... (truncated)
Commits
- 1055b48 Update version.go to 1.56.3 (#6713)
- 5efd7bd server: prohibit more than MaxConcurrentStreams handlers from running at once...
- bd1f038 Upgrade version.go to 1.56.3-dev (#6434)
- faab873 Update version.go to v1.56.2 (#6432)
- 6b0b291 status: fix panic when servers return a wrapped error with status OK (#6374) ...
- ed56401 [PSM interop] Don't fail target if sub-target already failed (#6390) (#6405)
- cd6a794 Update version.go to v1.56.2-dev (#6387)
- 5b67e5e Update version.go to v1.56.1 (#6386)
- d0f5150 client: handle empty address lists correctly in addrConn.updateAddrs (#6354) ...
- 997c1ea Change version to 1.56.1-dev (#6345)
- Additional commits viewable in compare view
[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=google.golang.org/grpc&package-manager=go_modules&previous-version=1.53.0&new-version=1.56.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) You can trigger a rebase of this PR by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---

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 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

457: Add support for SHOW EXTENDED COLUMNS syntax
Adds support for parsing the EXTENDED keyword as part of the SHOW EXTENDED COLUMNS syntax.
456: add AuthInformation to FuncExpr
455: go/mysql: Add some recycleWritePacket calls on error returning paths where the ephemeral packet was not previously returned.
453: Add support for serializing optional table map metadata
To support @@binlog_row_metadata = 'FULL', we need support for serializing optional table map metadata.
452: Bump google.golang.org/grpc from 1.24.0 to 1.56.3
Bumps google.golang.org/grpc from 1.24.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
- status: To fix a panic, status.FromError now returns an error with codes.Unknown when the error implements the GRPCStatus() method, and calling GRPCStatus() returns nil. (#6374)
Release 1.56.1
- client: handle empty address lists correctly in addrConn.updateAddrs
Release 1.56.0

New Features
- client: support channel idleness using WithIdleTimeout dial option (#6263)
  - This feature is currently disabled by default, but will be enabled with a 30 minute default in the future.
- client: when using pickfirst, keep channel state in TRANSIENT_FAILURE until it becomes READY (gRFC A62) (#6306)
- xds: Add support for Custom LB Policies (gRFC A52) (#6224)
- xds: support pick_first Custom LB policy (gRFC A62) (#6314) (#6317)
- client: add support for pickfirst address shuffling (gRFC A62) (#6311)
- xds: Add support for String Matcher Header Matcher in RDS (#6313)
- xds/outlierdetection: Add Channelz Logger to Outlier Detection LB (#6145)
  - Special Thanks: @s-matyukevich
- xds: enable RLS in xDS by default (#6343)
- orca: add support for application_utilization field and missing range checks on several metrics setters
- balancer/weightedroundrobin: add new LB policy for balancing between backends based on their load reports (gRFC A58) (#6241)
- authz: add conversion of json to RBAC Audit Logging config (#6192)
- authz: add support for stdout logger (#6230 and #6298)
- authz: support customizable audit functionality for authorization policy (#6192 #6230 #6298 #6158 #6304 and #6225)
Bug Fixes
- orca: fix a race at startup of out-of-band metric subscriptions that would cause the report interval to request 0 (#6245)
- xds/xdsresource: Fix Outlier Detection Config Handling and correctly set xDS Defaults (#6361)
- xds/outlierdetection: Fix Outlier Detection Config Handling by setting defaults in ParseConfig() (#6361)
API Changes
- orca: allow a ServerMetricsProvider to be passed to the ORCA service and ServerOption (#6223)
Release 1.55.1
- status: To fix a panic, status.FromError now returns an error with codes.Unknown when the error implements the GRPCStatus() method, and calling GRPCStatus() returns nil. (#6374)
Release 1.55.0

Behavior Changes
- xds: enable federation support by default (#6151)
- status: status.Code and status.FromError handle wrapped errors (#6031 and #6150)
... (truncated)
Commits
- 1055b48 Update version.go to 1.56.3 (#6713)
- 5efd7bd server: prohibit more than MaxConcurrentStreams handlers from running at once...
- bd1f038 Upgrade version.go to 1.56.3-dev (#6434)
- faab873 Update version.go to v1.56.2 (#6432)
- 6b0b291 status: fix panic when servers return a wrapped error with status OK (#6374) ...
- ed56401 [PSM interop] Don't fail target if sub-target already failed (#6390) (#6405)
- cd6a794 Update version.go to v1.56.2-dev (#6387)
- 5b67e5e Update version.go to v1.56.1 (#6386)
- d0f5150 client: handle empty address lists correctly in addrConn.updateAddrs (#6354) ...
- 997c1ea Change version to 1.56.1-dev (#6345)
- Additional commits viewable in compare view
[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=google.golang.org/grpc&package-manager=go_modules&previous-version=1.24.0&new-version=1.56.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) 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-automerge-start) [//]: # (dependabot-automerge-end) ---

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 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 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-automerge-start)
[//]: # (dependabot-automerge-end)

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 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 for NATURAL FULL JOINto be parsed correctly and also prevents invalid joins using theNATURAL` prefix from getting parsed.
446: Added DISTINCT ON expressions
Related PRs:
- dolthub/go-mysql-server#3369
- dolthub/doltgresql#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

dolthub/dolt v1.83.1 1.83.1 on GitHub

Merged PRs

dolt

go-mysql-server

Summary

Testing

Related

v1.8.3

What's Changed

New Contributors

v1.8.2

What's Changed

New Contributors

Implementation

Compatibility Notes

Release 1.56.3

Security

Release 1.56.2

Release 1.56.1

Release 1.56.0

New Features

Bug Fixes

API Changes

Release 1.55.1

Release 1.55.0

Behavior Changes