removing transaction committing node

Author: James Cor

engine.go

@@ -446,6 +446,8 @@ func (e *Engine) QueryWithBindings(ctx *sql.Context, query string, parsed sqlpar
 
 		return nil, nil, nil, err
 	}
+
+	iter = rowexec.AddTransactionCommittingIter(iter, qFlags)
 	iter = rowexec.AddExpressionCloser(analyzed, iter)
 
 	return analyzed.Schema(), iter, qFlags, nil
@@ -722,31 +724,6 @@ func (e *Engine) CloseSession(connID uint32) {
 	e.PreparedDataCache.DeleteSessionData(connID)
 }
 
-// Count number of BindVars in given tree
-func countBindVars(node sql.Node) int {
-	var bindVars map[string]bool
-	bindCntFunc := func(e sql.Expression) bool {
-		if bv, ok := e.(*expression.BindVar); ok {
-			if bindVars == nil {
-				bindVars = make(map[string]bool)
-			}
-			bindVars[bv.Name] = true
-		}
-		return true
-	}
-	transform.InspectExpressions(node, bindCntFunc)
-
-	// InsertInto.Source not a child of InsertInto, so also need to traverse those
-	transform.Inspect(node, func(n sql.Node) bool {
-		if in, ok := n.(*plan.InsertInto); ok {
-			transform.InspectExpressions(in.Source, bindCntFunc)
-			return false
-		}
-		return true
-	})
-	return len(bindVars)
-}
-
 func (e *Engine) beginTransaction(ctx *sql.Context) error {
 	beginNewTransaction := ctx.GetTransaction() == nil || plan.ReadCommitted(ctx)
 	if beginNewTransaction {

sql/analyzer/autocommit.go

@@ -54,10 +54,6 @@ func shouldParallelize(node sql.Node, scope *plan.Scope) bool {
 		return false
 	}
 
-	if tc, ok := node.(*plan.TransactionCommittingNode); ok {
-		return shouldParallelize(tc.Child(), scope)
-	}
-
 	// Do not try to parallelize DDL or descriptive operations
 	return !plan.IsNoRowNode(node)
 }

sql/analyzer/parallelize.go

@@ -296,8 +296,6 @@ func StripPassthroughNodes(n sql.Node) sql.Node {
 		switch tn := n.(type) {
 		case *plan.QueryProcess:
 			n = tn.Child()
-		case *plan.TransactionCommittingNode:
-			n = tn.Child()
 		default:
 			nodeIsPassthrough = false
 		}

sql/analyzer/resolve_subqueries.go

@@ -26,7 +26,6 @@ func init() {
 		{inlineSubqueryAliasRefsId, inlineSubqueryAliasRefs},
 		{cacheSubqueryAliasesInJoinsId, cacheSubqueryAliasesInJoins},
 		{backtickDefaulColumnValueNamesId, backtickDefaultColumnValueNames},
-		{AutocommitId, addAutocommit},
 		{TrackProcessId, trackProcess},
 		{parallelizeId, parallelize},
 	}

sql/analyzer/rules.go

@@ -15,7 +15,6 @@
 package plan
 
 import (
-	"fmt"
 	"os"
 
 	"github.com/dolthub/go-mysql-server/sql"
@@ -34,65 +33,6 @@ func init() {
 	}
 }
 
-// TransactionCommittingNode implements autocommit logic. It wraps relevant queries and ensures the database commits
-// the transaction.
-type TransactionCommittingNode struct {
-	UnaryNode
-}
-
-var _ sql.Node = (*TransactionCommittingNode)(nil)
-var _ sql.CollationCoercible = (*TransactionCommittingNode)(nil)
-
-// NewTransactionCommittingNode returns a TransactionCommittingNode.
-func NewTransactionCommittingNode(child sql.Node) *TransactionCommittingNode {
-	return &TransactionCommittingNode{UnaryNode: UnaryNode{Child: child}}
-}
-
-// String implements the sql.Node interface.
-func (t *TransactionCommittingNode) String() string {
-	return t.Child().String()
-}
-
-// DebugString implements the sql.DebugStringer interface.
-func (t *TransactionCommittingNode) DebugString() string {
-	return sql.DebugString(t.Child())
-}
-
-// Describe implements the sql.Describable interface.
-func (t *TransactionCommittingNode) Describe(options sql.DescribeOptions) string {
-	return sql.Describe(t.Child(), options)
-}
-
-func (t *TransactionCommittingNode) IsReadOnly() bool {
-	return t.Child().IsReadOnly()
-}
-
-// WithChildren implements the sql.Node interface.
-func (t *TransactionCommittingNode) WithChildren(children ...sql.Node) (sql.Node, error) {
-	if len(children) != 1 {
-		return nil, fmt.Errorf("ds")
-	}
-
-	t2 := *t
-	t2.UnaryNode = UnaryNode{Child: children[0]}
-	return &t2, nil
-}
-
-// CheckPrivileges implements the sql.Node interface.
-func (t *TransactionCommittingNode) CheckPrivileges(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool {
-	return t.Child().CheckPrivileges(ctx, opChecker)
-}
-
-// CollationCoercibility implements the interface sql.CollationCoercible.
-func (*TransactionCommittingNode) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte) {
-	return sql.Collation_binary, 7
-}
-
-// Child implements the sql.UnaryNode interface.
-func (t *TransactionCommittingNode) Child() sql.Node {
-	return t.UnaryNode.Child
-}
-
 // IsSessionAutocommit returns true if the current session is using implicit transaction management
 // through autocommit.
 func IsSessionAutocommit(ctx *sql.Context) (bool, error) {

sql/plan/transaction_committing_iter.go

@@ -54,8 +54,6 @@ func (b *BaseBuilder) buildNodeExecNoAnalyze(ctx *sql.Context, n sql.Node, row s
 		return b.buildCreateRole(ctx, n, row)
 	case *plan.Loop:
 		return b.buildLoop(ctx, n, row)
-	case *plan.TransactionCommittingNode:
-		return b.buildTransactionCommittingNode(ctx, n, row)
 	case *plan.DropColumn:
 		return b.buildDropColumn(ctx, n, row)
 	case *plan.AnalyzeTable:

sql/rowexec/node_builder.gen.go

@@ -300,11 +300,3 @@ func (b *BaseBuilder) buildExecuteQuery(ctx *sql.Context, n *plan.ExecuteQuery,
 func (b *BaseBuilder) buildUse(ctx *sql.Context, n *plan.Use, row sql.Row) (sql.RowIter, error) {
 	return n.RowIter(ctx, row)
 }
-
-func (b *BaseBuilder) buildTransactionCommittingNode(ctx *sql.Context, n *plan.TransactionCommittingNode, row sql.Row) (sql.RowIter, error) {
-	iter, err := b.Build(ctx, n.Child(), row)
-	if err != nil {
-		return nil, err
-	}
-	return &TransactionCommittingIter{childIter: iter}, nil
-}

sql/rowexec/transaction.go

@@ -74,6 +74,14 @@ type TransactionCommittingIter struct {
 	transactionDatabase string
 }
 
+func AddTransactionCommittingIter(child sql.RowIter, qFlags *sql.QueryFlags) sql.RowIter {
+	// TODO: This is a bit of a hack. Need to figure out better relationship between new transaction node and warnings.
+	if qFlags != nil && qFlags.IsSet(sql.QFlagShowWarnings) {
+		return child
+	}
+	return &TransactionCommittingIter{childIter: child}
+}
+
 func (t *TransactionCommittingIter) Next(ctx *sql.Context) (sql.Row, error) {
 	return t.childIter.Next(ctx)
 }