sql: include write buffering info to EXPLAIN ANALYZE top level

In order to make it easier to notice that write buffering is enabled, we
now will include top-level `write buffering enabled` message to the
output of EXPLAIN ANALYZE when write buffering is enabled for all
mutations as well as read-only stmts that are part of explicit txns.

Release note: None

Author: yuzefovich

pkg/sql/explain_test.go

@@ -29,6 +29,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/util/timeutil"
 	"github.com/cockroachdb/errors"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestStatementReuses(t *testing.T) {
@@ -645,3 +646,93 @@ func TestExplainAnalyzeSQLNodes(t *testing.T) {
 		})
 	}
 }
+
+// TestExplainAnalyzeBufferedWrites verifies that write buffering info is
+// printed only when applicable.
+func TestExplainAnalyzeBufferedWrites(t *testing.T) {
+	defer leaktest.AfterTest(t)()
+	defer log.Scope(t).Close(t)
+
+	ctx := context.Background()
+	srv, godb, _ := serverutils.StartServer(t, base.TestServerArgs{})
+	defer srv.Stopper().Stop(ctx)
+
+	conn, err := godb.Conn(ctx)
+	require.NoError(t, err)
+	_, err = conn.ExecContext(ctx, `CREATE TABLE t (v INT);`)
+	require.NoError(t, err)
+
+	for _, tc := range []struct {
+		setup       []string
+		cleanup     string
+		query       string
+		infoPrinted bool
+	}{
+		{ // disabled
+			setup:       []string{`SET kv_transaction_buffered_writes_enabled = false;`},
+			query:       `INSERT INTO t VALUES (1)`,
+			infoPrinted: false,
+		},
+		{ // enabled
+			setup:       []string{`SET kv_transaction_buffered_writes_enabled = true;`},
+			query:       `INSERT INTO t VALUES (1), (2)`,
+			infoPrinted: true,
+		},
+		// In this case we won't actually buffer any writes, so the write
+		// buffering effectively gets disabled during the stmt execution, but we
+		// still include the info.
+		// TODO(yuzefovich): consider differentiating this case if it becomes
+		// frequent. For now it seems ok since we'll have a message in the trace
+		// about this switch.
+		{
+			setup: []string{
+				`SET kv_transaction_buffered_writes_enabled = true;`,
+				`SET CLUSTER SETTING kv.transaction.write_buffering.max_buffer_size = '1B';`,
+			},
+			cleanup:     `RESET CLUSTER SETTING kv.transaction.write_buffering.max_buffer_size;`,
+			query:       `INSERT INTO t VALUES (1), (2), (3)`,
+			infoPrinted: true,
+		},
+		{ // read-only implicit
+			setup:       []string{`SET kv_transaction_buffered_writes_enabled = true;`},
+			query:       `SELECT * FROM t`,
+			infoPrinted: false,
+		},
+		{ // read-only explicit
+			setup: []string{
+				`SET kv_transaction_buffered_writes_enabled = true;`,
+				`BEGIN;`,
+			},
+			cleanup:     `COMMIT;`,
+			query:       `SELECT * FROM t`,
+			infoPrinted: true,
+		},
+	} {
+		for _, stmt := range tc.setup {
+			_, err = conn.ExecContext(ctx, stmt)
+			require.NoError(t, err)
+		}
+		result, err := conn.QueryContext(ctx, "EXPLAIN ANALYZE "+tc.query)
+		require.NoError(t, err)
+		rows, err := sqlutils.RowsToStrMatrix(result)
+		require.NoError(t, err)
+		var printed bool
+		for _, row := range rows {
+			if len(row) > 1 {
+				t.Fatalf("unexpectedly more than a single string is returned in %v", row)
+			}
+			if strings.Contains(row[0], "buffered writes enabled") {
+				printed = true
+			}
+		}
+		if printed != tc.infoPrinted {
+			var negate string
+			if !tc.infoPrinted {
+				negate = "not "
+			}
+			t.Fatalf("expected 'buffered writes enabled' to %sbe printed", negate)
+		}
+		_, err = conn.ExecContext(ctx, tc.cleanup)
+		require.NoError(t, err)
+	}
+}

pkg/sql/instrumentation.go

@@ -80,6 +80,9 @@ type instrumentationHelper struct {
 	// Transaction information.
 	implicitTxn bool
 	txnPriority roachpb.UserPriority
+	// txnBufferedWritesEnabled tracks whether the write buffering was
+	// enabled on the transaction before executing the stmt.
+	txnBufferedWritesEnabled bool
 
 	codec keys.SQLCodec
 
@@ -420,6 +423,7 @@ func (ih *instrumentationHelper) Setup(
 	ih.fingerprint = stmt.StmtNoConstants
 	ih.implicitTxn = implicitTxn
 	ih.txnPriority = txnPriority
+	ih.txnBufferedWritesEnabled = p.txn.BufferedWritesEnabled()
 	ih.retryCount = uint64(retryCount)
 	ih.codec = cfg.Codec
 	ih.origCtx = ctx
@@ -883,6 +887,18 @@ func (ih *instrumentationHelper) emitExplainAnalyzePlanToOutputBuilder(
 		asOfSystemTime = ih.evalCtx.AsOfSystemTime
 	}
 	ob.AddTxnInfo(iso, ih.txnPriority, qos, asOfSystemTime)
+	// Highlight that write buffering was enabled on the current txn, unless
+	// we're in "deterministic explain" mode.
+	if ih.txnBufferedWritesEnabled && !flags.Deflake.HasAny(explain.DeflakeAll) {
+		// In order to not pollute the output, we don't include the write
+		// buffering info for read-only implicit txns. However, if we're in an
+		// explicit txn, even if the stmt is read-only, it might still be
+		// helpful to highlight the write buffering being enabled.
+		readOnlyImplicit := !ih.containsMutation && ih.implicitTxn
+		if !readOnlyImplicit {
+			ob.AddTopLevelField("buffered writes enabled", "")
+		}
+	}
 
 	// When building EXPLAIN ANALYZE output we do **not** want to create
 	// post-query plans if they are missing. The fact that they are missing