When applying indexes from outer scopes, resolve references to table aliases

sql/analyzer/apply_indexes_from_outer_scope.go

@@ -278,7 +278,7 @@ func tablesInScope(scope *plan.Scope) []string {
 		}
 	}
 	for _, table := range scope.JoinSiblings() {
-		for name, _ := range getTablesByName(table) {
+		for name, _ := range getNamedChildren(table) {
 			tables[name] = true
 		}
 	}

sql/analyzer/assign_update_join.go

@@ -51,7 +51,7 @@ func modifyUpdateExprsForJoin(ctx *sql.Context, a *Analyzer, n sql.Node, scope *
 // getUpdateTargetsByTable maps a set of table names and aliases to their corresponding update target Node
 func getUpdateTargetsByTable(node sql.Node, ij sql.Node, isJoin bool) (map[string]sql.Node, error) {
 	namesOfTableToBeUpdated := plan.GetTablesToBeUpdated(node)
-	resolvedTables := getTablesByName(ij)
+	resolvedTables := getResolvedTablesByName(ij)
 
 	updateTargets := make(map[string]sql.Node)
 	for tableToBeUpdated, _ := range namesOfTableToBeUpdated {

sql/analyzer/resolve_subqueries.go

@@ -36,7 +36,7 @@ func resolveSubqueries(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Sc
 }
 
 func addLeftTablesToScope(outerScope *plan.Scope, leftNode sql.Node) *plan.Scope {
-	resTbls := getTablesByName(leftNode)
+	resTbls := getNamedChildren(leftNode)
 	subScope := outerScope
 	for _, tbl := range resTbls {
 		subScope = subScope.NewScopeInJoin(tbl)

sql/analyzer/tables.go

@@ -97,9 +97,9 @@ func getResolvedTable(node sql.Node) *plan.ResolvedTable {
 	return table
 }
 
-// getTablesByName takes a node and returns all found resolved tables in a map.
+// getResolvedTablesByName takes a node and returns all found resolved tables in a map.
 // This function will not look inside sql.OpaqueNodes (like plan.SubqueryAlias).
-func getTablesByName(node sql.Node) map[string]*plan.ResolvedTable {
+func getResolvedTablesByName(node sql.Node) map[string]*plan.ResolvedTable {
 	ret := make(map[string]*plan.ResolvedTable)
 	// TODO: We should change transform.Inspect to not walk the children of sql.OpaqueNodes (like transform.Node)
 	//  and add a transform.InspectWithOpaque that does.
@@ -123,3 +123,17 @@ func getTablesByName(node sql.Node) map[string]*plan.ResolvedTable {
 	})
 	return ret
 }
+
+func getNamedChildren(node sql.Node) map[string]sql.NameableNode {
+	ret := make(map[string]sql.NameableNode)
+	// TODO: We should change transform.Inspect to not walk the children of sql.OpaqueNodes (like transform.Node)
+	//  and add a transform.InspectWithOpaque that does.
+	//  Using transform.Node here achieves the same result without a large refactor.
+	transform.Node(node, func(node sql.Node) (sql.Node, transform.TreeIdentity, error) {
+		if nameable, ok := node.(sql.NameableNode); ok {
+			ret[strings.ToLower(nameable.Name())] = nameable
+		}
+		return nil, transform.SameTree, nil
+	})
+	return ret
+}

sql/planbuilder/dml.go

@@ -607,7 +607,7 @@ func hasJoinNode(node sql.Node) bool {
 
 func getResolvedTablesToUpdate(_ *sql.Context, node sql.Node, ij sql.Node) (resolvedTables []*plan.ResolvedTable, err error) {
 	namesOfTablesToBeUpdated := plan.GetTablesToBeUpdated(node)
-	resolvedTablesMap := getTablesByName(ij)
+	resolvedTablesMap := getResolvedTablesByName(ij)
 
 	for tableToBeUpdated, _ := range namesOfTablesToBeUpdated {
 		resolvedTable, ok := resolvedTablesMap[strings.ToLower(tableToBeUpdated)]
@@ -622,7 +622,7 @@ func getResolvedTablesToUpdate(_ *sql.Context, node sql.Node, ij sql.Node) (reso
 }
 
 // getTablesByName takes a node and returns all found resolved tables in a map.
-func getTablesByName(node sql.Node) map[string]*plan.ResolvedTable {
+func getResolvedTablesByName(node sql.Node) map[string]*plan.ResolvedTable {
 	ret := make(map[string]*plan.ResolvedTable)
 
 	transform.Inspect(node, func(node sql.Node) bool {

sql/planbuilder/scalar.go

@@ -1084,7 +1084,7 @@ func (b *Builder) ConvertVal(v *ast.SQLVal) sql.Expression {
 // filter, since we only need to load the tables once. All steps after this
 // one can assume that the expression has been fully resolved and is valid.
 func (b *Builder) buildMatchAgainst(inScope *scope, v *ast.MatchExpr) *expression.MatchAgainst {
-	rts := getTablesByName(inScope.node)
+	rts := getResolvedTablesByName(inScope.node)
 	var rt *plan.ResolvedTable
 	var matchTable string
 	cols := make([]*expression.GetField, len(v.Columns))