maybe?

Author: James Cor

sql/analyzer/fix_exec_indexes.go

@@ -161,7 +161,33 @@ type idxScope struct {
 	children      []sql.Node
 	expressions   []sql.Expression
 	checks        sql.CheckConstraints
-	triggerScope  bool
+
+	triggerScope      bool
+	insertSourceScope bool
+}
+
+func (s *idxScope) inTrigger() bool {
+	if s == nil {
+		return false
+	}
+	for _, ps := range s.parentScopes {
+		if ps.inTrigger() {
+			return true
+		}
+	}
+	return s.triggerScope
+}
+
+func (s *idxScope) inInsertSource() bool {
+	if s == nil {
+		return false
+	}
+	for _, ps := range s.parentScopes {
+		if ps.inInsertSource() {
+			return true
+		}
+	}
+	return s.insertSourceScope
 }
 
 func (s *idxScope) addSchema(sch sql.Schema) {
@@ -273,6 +299,9 @@ func (s *idxScope) copy() *idxScope {
 		parentScopes:  parentCopy,
 		columns:       varsCopy,
 		ids:           idsCopy,
+
+		triggerScope:      s.triggerScope,
+		insertSourceScope: s.insertSourceScope,
 	}
 }
 
@@ -339,10 +368,42 @@ func (s *idxScope) visitChildren(n sql.Node) error {
 		// keep only the first union scope to avoid double counting
 		s.childScopes = append(s.childScopes, keepScope)
 	case *plan.InsertInto:
-		newSrc, _, err := assignIndexesHelper(n.Source, s)
+		// TODO: special case into sources when in triggers with groupby/window functions
+		var newSrc sql.Node
+		var err error
+
+		// TODO: do something cleaner
+		//var isInTrigger bool
+		//for _, ps := range s.parentScopes {
+		//	if ps.triggerScope {
+		//		isInTrigger = true
+		//		break
+		//	}
+		//}
+		//if isInTrigger {
+		//	if proj, isProj := n.Source.(*plan.Project); isProj {
+		//		switch proj.Child.(type) {
+		//		case *plan.GroupBy, *plan.Window:
+		//			subScope := s.copy()
+		//			subScope.parentScopes = subScope.parentScopes[:0]
+		//			newSrc, _, err = assignIndexesHelper(proj, subScope)
+		//		default:
+		//			newSrc, _, err = assignIndexesHelper(n.Source, s)
+		//		}
+		//	} else {
+		//		newSrc, _, err = assignIndexesHelper(n.Source, s)
+		//	}
+		//} else {
+		//	newSrc, _, err = assignIndexesHelper(n.Source, s)
+		//}
+
+		s.insertSourceScope = true
+		newSrc, _, err = assignIndexesHelper(n.Source, s)
 		if err != nil {
 			return err
 		}
+		s.insertSourceScope = false
+
 		newDst, dScope, err := assignIndexesHelper(n.Destination, s)
 		if err != nil {
 			return err
@@ -362,15 +423,6 @@ func (s *idxScope) visitChildren(n sql.Node) error {
 			}
 			s.children = append(s.children, newC)
 		}
-	case *plan.GroupBy:
-		for _, c := range n.Children() {
-			newC, cScope, err := assignIndexesHelper(c, s)
-			if err != nil {
-				return err
-			}
-			s.childScopes = append(s.childScopes, cScope)
-			s.children = append(s.children, newC)
-		}
 	default:
 		for _, c := range n.Children() {
 			if _, ok := c.(*plan.GroupBy); ok {
@@ -547,22 +599,18 @@ func (s *idxScope) visitSelf(n sql.Node) error {
 			n.DestSch[colIdx].Default = newDef.(*sql.ColumnDefaultValue)
 		}
 	default:
+		// TODO: this very specific pattern
 		if proj, isProj := n.(*plan.Project); isProj {
-			if _, isGb := proj.Child.(*plan.GroupBy); isGb {
-				for _, e := range proj.Expressions() {
-					// default nodes can't see lateral join nodes, unless we're in lateral
-					// join and lateral scopes are promoted to parent status
-					s.expressions = append(s.expressions, fixExprToScope(e, s.childScopes...))
-				}
-				return nil
-			}
-			if _, isGb := proj.Child.(*plan.Window); isGb {
-				for _, e := range proj.Expressions() {
-					// default nodes can't see lateral join nodes, unless we're in lateral
-					// join and lateral scopes are promoted to parent status
-					s.expressions = append(s.expressions, fixExprToScope(e, s.childScopes...))
+			switch proj.Child.(type) {
+			case *plan.GroupBy, *plan.Window:
+				if s.inTrigger() && s.inInsertSource() {
+					for _, e := range proj.Expressions() {
+						// default nodes can't see lateral join nodes, unless we're in lateral
+						// join and lateral scopes are promoted to parent status
+						s.expressions = append(s.expressions, fixExprToScope(e, s.childScopes...))
+					}
+					return nil
 				}
-				return nil
 			}
 		}
 		if ne, ok := n.(sql.Expressioner); ok {

sql/analyzer/inserts.go

@@ -31,7 +31,8 @@ import (
 func resolveInsertRows(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, sel RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
 	if _, ok := n.(*plan.TriggerExecutor); ok {
 		return n, transform.SameTree, nil
-	} else if _, ok := n.(*plan.CreateProcedure); ok {
+	}
+	if _, ok := n.(*plan.CreateProcedure); ok {
 		return n, transform.SameTree, nil
 	}
 	// We capture all INSERTs along the tree, such as those inside of block statements.
@@ -50,14 +51,22 @@ func resolveInsertRows(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Sc
 
 		source := insert.Source
 		// TriggerExecutor has already been analyzed
-		if _, ok := insert.Source.(*plan.TriggerExecutor); !ok && !insert.LiteralValueSource {
+		if _, isTrigExec := insert.Source.(*plan.TriggerExecutor); !isTrigExec && !insert.LiteralValueSource {
 			// Analyze the source of the insert independently
 			if _, ok := insert.Source.(*plan.Values); ok {
 				scope = scope.NewScope(plan.NewProject(
 					expression.SchemaToGetFields(insert.Source.Schema()[:len(insert.ColumnNames)], sql.ColSet{}),
 					plan.NewSubqueryAlias("dummy", "", insert.Source),
 				))
 			}
+			//if proj, ok := insert.Source.(*plan.Project); ok {
+			//	if _, ok := proj.Child.(*plan.GroupBy); ok {
+			//		scope = &plan.Scope{}
+			//	}
+			//	if _, ok := proj.Child.(*plan.Window); ok {
+			//		scope = &plan.Scope{}
+			//	}
+			//}
 			source, _, err = a.analyzeWithSelector(ctx, insert.Source, scope, SelectAllBatches, newInsertSourceSelector(sel), qFlags)
 			if err != nil {
 				return nil, transform.SameTree, err