Merged PRs

dolt

• 2179: Added a method for database provider to override the functions provid…
  …ed (for dolthub)
• 2178: Upgrade gms and changed engine initialization pattern
• 2160: Change default init branch to main, add dolt init --branch flag
  This PR changes the default init branch to main, adds a --branch flag to dolt init and changes the clone checkout behavior to prioritize main, then master, then the first sorted branch. https://www.dolthub.com/blog/2021-09-29-dolt-and-dolthub-init-main/
• 2151: replicate HEAD on commit
  • prototype commit replication
  • only works for cli, will work for SQL after https://github.com/dolthub/dolt/pull/2137/files is merged
  • because the init state is in cli, the target dataset in datas, and logic for manipulating datasets is constrained to doltdb, this is what fell out without rearranging dependencies or exposing private fields
  • type CommitHook func(ctx context.Context, ds Dataset, db Database) error isn't super flexible
• 2094: optimize keyless read row

go-mysql-server

• 565: sql: Removing ctx parameter from Expression.WithChildren.
  Also removes it from FunctionFn types, TransformExpression... functions, and Aggregation.NewBuffer.
  We think this ctx parameter might have been added a few months ago as part of some optimization work which never made it across the line. Instead of threading a *sql.Context everywhere, if we have need of a *sql.Context during analysis or to precompute or materialize a certain result in the future, I think I'm going to advocate for a specific optional interface that the analyzer is aware of. It could then pass the context through at a specific analyzer phase and the function/expression node would have the opportunity to get ready to do what it needs to.
• 564: sql/plan: Defer returning error from IndexedInSubqueryFilter.RowIter until the Next() call.
  Fixes some interactions between INSERT IGNORE INTO and expressions which will
  fail on evaluation.
  This might be a credible strategy everywhere we .Eval within RowIter, for
  example, in indexed_table_access.
• 563: Added an extension point for custom function providers
  As part of this, embarked on a major refactor:
  • Extracted interfaces for sql.Catalog and sql.ProcessList
  • Moved existing sql.Catalog to analyzer package
  • Moved ProcessList and MemoryManager out of Catalog
  • Changed Analyzer and Engine to take a DatabaseProvider instead of a Catalog
• 560: Update some analyzer rules and expression behavior to deal with tuples in a more principled way.
  Subquery expression nodes can now return tuples.
  InSubquery expression nodes can work with tuples as expected.
  An analyzer validation step now returns operand errors in more cases, expecting
  almost all expressions to return one column, but special casing certain
  operators and functions which support tuples.
  Added some TODO tests for cases where our tuple comparisons are still not
  behaving as we want them to. In particular, null safe vs. non-null safe
  comparisons and type coercion of tuple subtypes in comparisons still need work.
• 559: sql/analyzer: aliases.go: Make sure we add the right table alias when traversing a DecoratedNode.
• 557: sql/analyzer/optimization_rules.go: moveJoinConditionsToFilter: Fix small inaccuracy where computed topJoin could be wrong.
  This could result in the optimization pass adding the same Filter node to
  multiple places in the join tree.
• 556: sql/plan/indexed_table_access.go: Change static index lookup nodes to not keep returning their unused key expressions.
  These needs take key expressions, but they do not evaluate them. They are not
  part of the evaluation tree, but they cause some problems with things like
  FixFieldIndexes and prune_columns, where all GetField expressions in the plan
  tree are expected to resolve to fields that are actually in scope and
  resolvable at the node that is being evaluated.
  This fixes a particular evaluation bug where a subquery expression in a join
  condition gets moved to the filter above the joins. If the moved subquery
  expression made use of a static index table lookup, the moved expression would
  fail to rewrite its field indexes appropriately and the query would return
  incorrect results.
• 554: Added locks, todo to mutable session state

Closed Issues

• 2167: Publish new releases via Chocolatey