Merged PRs

dolt

• 5828: go/store/nbs: reduce startup latency for chunk journal
  #5393 added a "journal index" to accelerate chunk journal bootstrapping. Unfortunately it never worked! Bugs in the journal index bootstrapping process caused sanity checks to fail and the journal index was subsequently dropped. The chunk journal itself was still valid and the bugs had no effect on correctness. However, without a valid journal index we were forced to always take the slow-path on startup.

go-mysql-server

• 1739: Populating the Decimal property in Field response metadata
  Fixes #5834
  In addition to the unit tests here, I'm also working on a Dolt PR to update the mysql connector library integration tests to test the Ruby mysql2 library.
• 1737: Coalesce.Type() needs to handle type types.Null
  Coalesce.Type() only checks if its arguments to have type nil. But NULL constants have type types.Null, and we need to check for that too.
• 1735: only hash expression.UnresolvedColumn for OnDuplicateExpressions
  Special logic is used to qualify columns for InsertInto.OnDuplicateExprs. Since qualify uses transform.OneNodeExprWithNode it will try to qualify all expressions (Literals, Tuples, etc). This change makes it so that we only try to qualify Columns.
  fix for: #5799
• 1728: hashjoin indexing
  When we have plan of the following format:

  InSubquery
  ...
  CrossJoin
  Left: Table
  Right: SubqueryAlias
  OuterScopeVisibility: true
  ...
  HashJoin
  HashLookup
  source: ...
  target: TableAlias
  ...
  

  The indexes we assign to GetFields during analysis don't align with the indexes of the actual columns in each row during execution time. This is a result of StripNode, PrependNode, and the nested Joins with SubqueryAlias.
  This error wasn't caught sooner as the incorrect indexes are too low, so they never threw IndexOutOfBounds errors and just returned potentially incorrect results instead.
  The fix was to correct these indexes at analysis time.
  Firstly, SubqueryAlias nodes with OuterScopeVisibilty = true inside joins need to see the left sibling node (in addition to the parent nodes). So Scope was modified to include some new fields, specifically for sibling nodes. Additionally, the file finalizeSubquery was changed to track the parent as well, so we could detect when we're analyzing a SubqueryAlias on the right side of a join, and add the left child to the scope.
  Additionally, pushdownFilters was modified to not undo all the changes to the Analyzer for HashLookups.
  At runtime, the PrependRow nodes cache the rows outside the InSubquery, while the buildJoinIter for CrossJoin would include both the outside and the left row. This meant that some parts of the inner HashJoin would receive extra columns while others didn't. The fix here was to alter the scope.InJoin depending on which parts of HashJoin we were building.
  Lastly, to have these changes not break for PreparedStatements, we just needed to not redo finalizeUnions in postPrepared, as we don't replan joins in postPrepared, so we don't know if we're in a join or not, and the correct indexes are set in prePrepared.
  Along the way, we discovered a query that panics, but the cause is different than the purpose of this fix, and it panicked the same way before these changes, so it is left as a skipped test.
  Fix for: #5714
• 1726: subquery indexing tests

Closed Issues

• 5826: Coalesce returning wrong value
• 5799: Constraints with tuples cause panic
• 3967: Add an equivalent to .gitignore.

Latency