remove rowupdateaccumulator node

Author: James Cor

enginetest/memory_engine_test.go

@@ -197,24 +197,12 @@ func TestSingleQueryPrepared(t *testing.T) {
 
 // Convenience test for debugging a single query. Unskip and set to the desired query.
 func TestSingleScript(t *testing.T) {
-	//t.Skip()
+	t.Skip()
 	var scripts = []queries.ScriptTest{
 		{
-			Name: "test script",
-			SetUpScript: []string{
-				"create table t (i int primary key);",
-				"create procedure p() begin insert into t values (1); end;",
-			},
-			Assertions: []queries.ScriptTestAssertion{
-				{
-					Query:    "call p();",
-					Expected: []sql.Row{},
-				},
-				//{
-				//	Query:    "update t join (values row(1), row(2)) t2 (j) on t.i = t2.j set t.i = 10;",
-				//	Expected: []sql.Row{},
-				//},
-			},
+			Name:        "test script",
+			SetUpScript: []string{},
+			Assertions:  []queries.ScriptTestAssertion{},
 		},
 	}
 

sql/analyzer/apply_foreign_keys.go

@@ -190,22 +190,6 @@ func applyForeignKeysToNodes(ctx *sql.Context, a *Analyzer, n sql.Node, cache *f
 			}
 			return newNode, transform.NewTree, nil
 		}
-	case *plan.RowUpdateAccumulator:
-		children := n.Children()
-		newChildren := make([]sql.Node, len(children))
-		treeIdentity := transform.SameTree
-		for i, child := range children {
-			newIdentity := transform.SameTree
-			newChildren[i], newIdentity, err = applyForeignKeysToNodes(ctx, a, child, cache)
-			if err != nil {
-				return nil, transform.SameTree, err
-			}
-			if newIdentity == transform.NewTree {
-				treeIdentity = transform.NewTree
-			}
-		}
-		nn, err := n.WithChildren(newChildren...)
-		return nn, treeIdentity, err
 	default:
 		return n, transform.SameTree, nil
 	}

sql/analyzer/apply_update_accumulators.go

@@ -66,7 +66,6 @@ const (
 	applyProceduresId            // applyProcedures
 	assignRoutinesId             // assignRoutines
 	modifyUpdateExprsForJoinId   // modifyUpdateExprsForJoin
-	applyUpdateAccumulatorsId    // applyUpdateAccumulators
 	applyForeignKeysId           // applyForeignKeys
 
 	// validate

sql/analyzer/rule_ids.go

@@ -21,7 +21,6 @@ func init() {
 		{resolveInsertRowsId, resolveInsertRows},
 		{applyTriggersId, applyTriggers},
 		{applyProceduresId, applyProcedures},
-		{applyUpdateAccumulatorsId, applyUpdateAccumulators},
 		{inlineSubqueryAliasRefsId, inlineSubqueryAliasRefs},
 		{cacheSubqueryAliasesInJoinsId, cacheSubqueryAliasesInJoins},
 		{BacktickDefaulColumnValueNamesId, backtickDefaultColumnValueNames},

sql/analyzer/ruleid_string.go

@@ -423,13 +423,6 @@ func getUpdateJoinSource(n sql.Node) *plan.UpdateSource {
 // getTriggerLogic analyzes and returns the Node representing the trigger body for the trigger given, applied to the
 // plan node given, which must be an insert, update, or delete.
 func getTriggerLogic(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, trigger *plan.CreateTrigger, qFlags *sql.QueryFlags) (sql.Node, error) {
-	// For trigger body analysis, we don't want any row update accumulators applied to insert / update / delete
-	// statements, we need the raw output from them.
-	var noRowUpdateAccumulators RuleSelector
-	noRowUpdateAccumulators = func(id RuleId) bool {
-		return DefaultRuleSelector(id) && id != applyUpdateAccumulatorsId
-	}
-
 	// For the reference to the row in the trigger table, we use the scope mechanism. This is a little strange because
 	// scopes for subqueries work with the child schemas of a scope node, but we don't have such a node here. Instead we
 	// fabricate one with the right properties (its child schema matches the table schema, with the right aliased name)
@@ -444,7 +437,7 @@ func getTriggerLogic(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scop
 			plan.NewTableAlias("new", trigger.Table),
 		)
 		s := (*plan.Scope)(nil).NewScope(scopeNode).WithMemos(scope.Memo(n).MemoNodes()).WithProcedureCache(scope.ProcedureCache())
-		triggerLogic, _, err = a.analyzeWithSelector(ctx, trigger.Body, s, SelectAllBatches, noRowUpdateAccumulators, qFlags)
+		triggerLogic, _, err = a.analyzeWithSelector(ctx, trigger.Body, s, SelectAllBatches, DefaultRuleSelector, qFlags)
 	case sqlparser.UpdateStr:
 		var scopeNode *plan.Project
 		if updateSrc := getUpdateJoinSource(n); updateSrc == nil {
@@ -467,15 +460,15 @@ func getTriggerLogic(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scop
 		}
 		// Triggers are wrapped in prepend nodes, which means that the parent scope is included
 		s := (*plan.Scope)(nil).NewScope(scopeNode).WithMemos(scope.Memo(n).MemoNodes()).WithProcedureCache(scope.ProcedureCache())
-		triggerLogic, _, err = a.analyzeWithSelector(ctx, trigger.Body, s, SelectAllBatches, noRowUpdateAccumulators, qFlags)
+		triggerLogic, _, err = a.analyzeWithSelector(ctx, trigger.Body, s, SelectAllBatches, DefaultRuleSelector, qFlags)
 	case sqlparser.DeleteStr:
 		scopeNode := plan.NewProject(
 			[]sql.Expression{expression.NewStar()},
 			plan.NewTableAlias("old", trigger.Table),
 		)
 		// Triggers are wrapped in prepend nodes, which means that the parent scope is included
 		s := scope.NewScope(scopeNode)
-		triggerLogic, _, err = a.analyzeWithSelector(ctx, trigger.Body, s, SelectAllBatches, noRowUpdateAccumulators, qFlags)
+		triggerLogic, _, err = a.analyzeWithSelector(ctx, trigger.Body, s, SelectAllBatches, DefaultRuleSelector, qFlags)
 	}
 
 	return triggerLogic, err

sql/analyzer/rules.go

@@ -74,10 +74,7 @@ func (tc *TableCopier) ProcessCreateTable(ctx *sql.Context, b sql.NodeExecBuilde
 	// TODO: Improve parsing for CREATE TABLE SELECT to allow for IGNORE/REPLACE and custom specs
 	ii := NewInsertInto(tc.db, NewResolvedTable(table, tc.db, nil), tc.Source, tc.options.replace, nil, nil, tc.options.ignore)
 
-	// Wrap the insert into a row update accumulator
-	roa := NewRowUpdateAccumulator(ii, UpdateTypeInsert)
-
-	return b.Build(ctx, roa, row)
+	return b.Build(ctx, ii, row)
 }
 
 // createTableSelectCanBeCopied determines whether the newly created table's data can just be copied from the Source table