sql/row: lazily compute index column direction slices

The encoding directions of the primary and secondary indexes are only
used in mutations when pretty-printing keys when tracing is enabled and
when `CheckRowSize` emits a log event. These encoding directions are now
lazily computed to eliminate their overhead in the common case.

Release note: None

Author: mgartner

pkg/sql/row/deleter.go

@@ -179,10 +179,10 @@ func (rd *Deleter) DeleteRow(
 			if oth.IsSet() {
 				oth.DelWithCPut(ctx, b, &rd.key, expValue, traceKV)
 			} else {
-				delWithCPutFn(ctx, b, &rd.key, expValue, traceKV, rd.Helper.primIndexValDirs)
+				delWithCPutFn(ctx, b, &rd.key, expValue, traceKV, &rd.Helper, primaryIndexDirs)
 			}
 		} else {
-			delFn(ctx, b, &rd.key, !rd.primaryLocked /* needsLock */, traceKV, rd.Helper.primIndexValDirs)
+			delFn(ctx, b, &rd.key, !rd.primaryLocked /* needsLock */, traceKV, &rd.Helper, primaryIndexDirs)
 		}
 
 		rd.key = nil
@@ -218,7 +218,7 @@ func (rd *Deleter) DeleteRow(
 		for _, e := range entries {
 			if err = rd.Helper.deleteIndexEntry(
 				ctx, b, index, &e.Key, alreadyLocked, rd.Helper.sd.BufferedWritesUseLockingOnNonUniqueIndexes,
-				traceKV, rd.Helper.secIndexValDirs[i],
+				traceKV, secondaryIndexDirs(i),
 			); err != nil {
 				return err
 			}

pkg/sql/row/helper.go

@@ -91,9 +91,11 @@ type RowHelper struct {
 	UniqueWithTombstoneIndexes intsets.Fast
 	indexEntries               map[catalog.Index][]rowenc.IndexEntry
 
-	// Computed during initialization for pretty-printing.
-	primIndexValDirs []encoding.Direction
-	secIndexValDirs  [][]encoding.Direction
+	// Lazily computed for pretty-printing and CheckRowSize.
+	dirs struct {
+		primary   []encoding.Direction
+		secondary [][]encoding.Direction
+	}
 
 	// Computed and cached.
 	PrimaryIndexKeyPrefix []byte
@@ -126,28 +128,50 @@ func NewRowHelper(
 	for _, index := range uniqueWithTombstoneIndexes {
 		uniqueWithTombstoneIndexesSet.Add(index.Ordinal())
 	}
-	rh := RowHelper{
+	return RowHelper{
 		Codec:                      codec,
 		TableDesc:                  desc,
 		Indexes:                    indexes,
 		UniqueWithTombstoneIndexes: uniqueWithTombstoneIndexesSet,
 		sd:                         sd,
 		metrics:                    metrics,
+		maxRowSizeLog:              uint32(maxRowSizeLog.Get(sv)),
+		maxRowSizeErr:              uint32(maxRowSizeErr.Get(sv)),
 	}
+}
 
-	// Pre-compute the encoding directions of the index key values for
-	// pretty-printing in traces.
-	rh.primIndexValDirs = catalogkeys.IndexKeyValDirs(rh.TableDesc.GetPrimaryIndex())
+// lazyIndexDirs represents encoding directions of an index. Those directions
+// may not have been, and may never be computed. The value of -2 represents
+// empty encoding directions. The value of -1 represents the encoding directions
+// of the primary index, otherwise a value i represents the encoding directions
+// of the i-th secondary index.
+type lazyIndexDirs int
 
-	rh.secIndexValDirs = make([][]encoding.Direction, len(rh.Indexes))
-	for i := range rh.Indexes {
-		rh.secIndexValDirs[i] = catalogkeys.IndexKeyValDirs(rh.Indexes[i])
-	}
+const (
+	emptyIndexDirs   lazyIndexDirs = -2
+	primaryIndexDirs lazyIndexDirs = -1
+)
 
-	rh.maxRowSizeLog = uint32(maxRowSizeLog.Get(sv))
-	rh.maxRowSizeErr = uint32(maxRowSizeErr.Get(sv))
+func secondaryIndexDirs(i int) lazyIndexDirs { return lazyIndexDirs(i) }
 
-	return rh
+func (d lazyIndexDirs) compute(rh *RowHelper) []encoding.Direction {
+	switch d {
+	case emptyIndexDirs:
+		return nil
+	case primaryIndexDirs:
+		if rh.dirs.primary == nil {
+			rh.dirs.primary = catalogkeys.IndexKeyValDirs(rh.TableDesc.GetPrimaryIndex())
+		}
+		return rh.dirs.primary
+	default:
+		if rh.dirs.secondary == nil {
+			rh.dirs.secondary = make([][]encoding.Direction, len(rh.Indexes))
+			for i := range rh.Indexes {
+				rh.dirs.secondary[i] = catalogkeys.IndexKeyValDirs(rh.Indexes[i])
+			}
+		}
+		return rh.dirs.secondary[d]
+	}
 }
 
 // encodeIndexes encodes the primary and secondary index keys. The
@@ -432,7 +456,7 @@ func (rh *RowHelper) CheckRowSize(
 		RowSize:    size,
 		TableID:    uint32(rh.TableDesc.GetID()),
 		FamilyID:   uint32(family),
-		PrimaryKey: keys.PrettyPrint(rh.primIndexValDirs, *key),
+		PrimaryKey: keys.PrettyPrint(primaryIndexDirs.compute(rh), *key),
 	}
 	if rh.sd.Internal && shouldErr {
 		// Internal work should never err and always log if violating either limit.
@@ -471,11 +495,12 @@ func delFn(
 	key *roachpb.Key,
 	needsLock bool,
 	traceKV bool,
-	keyEncodingDirs []encoding.Direction,
+	rh *RowHelper,
+	dirs lazyIndexDirs,
 ) {
 	if needsLock {
 		if traceKV {
-			if keyEncodingDirs != nil {
+			if keyEncodingDirs := dirs.compute(rh); keyEncodingDirs != nil {
 				log.VEventf(ctx, 2, "Del (locking) %s", keys.PrettyPrint(keyEncodingDirs, *key))
 			} else {
 				log.VEventf(ctx, 2, "Del (locking) %s", *key)
@@ -484,7 +509,7 @@ func delFn(
 		b.DelMustAcquireExclusiveLock(key)
 	} else {
 		if traceKV {
-			if keyEncodingDirs != nil {
+			if keyEncodingDirs := dirs.compute(rh); keyEncodingDirs != nil {
 				log.VEventf(ctx, 2, "Del %s", keys.PrettyPrint(keyEncodingDirs, *key))
 			} else {
 				log.VEventf(ctx, 2, "Del %s", *key)
@@ -500,10 +525,11 @@ func delWithCPutFn(
 	key *roachpb.Key,
 	expVal []byte,
 	traceKV bool,
-	keyEncodingDirs []encoding.Direction,
+	rh *RowHelper,
+	dirs lazyIndexDirs,
 ) {
 	if traceKV {
-		if keyEncodingDirs != nil {
+		if keyEncodingDirs := dirs.compute(rh); keyEncodingDirs != nil {
 			log.VEventf(ctx, 2, "CPut %s -> nil (delete)", keys.PrettyPrint(keyEncodingDirs, *key))
 		} else {
 			log.VEventf(ctx, 2, "CPut %s -> nil (delete)", *key)
@@ -520,7 +546,7 @@ func (rh *RowHelper) deleteIndexEntry(
 	alreadyLocked bool,
 	lockNonUnique bool,
 	traceKV bool,
-	valDirs []encoding.Direction,
+	dirs lazyIndexDirs,
 ) error {
 	needsLock := !alreadyLocked && (index.IsUnique() || lockNonUnique)
 	if index.UseDeletePreservingEncoding() {
@@ -537,7 +563,7 @@ func (rh *RowHelper) deleteIndexEntry(
 			b.Put(key, deleteEncoding)
 		}
 	} else {
-		delFn(ctx, b, key, needsLock, traceKV, valDirs)
+		delFn(ctx, b, key, needsLock, traceKV, rh, dirs)
 	}
 	return nil
 }

pkg/sql/row/inserter.go

@@ -16,7 +16,6 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/sql/rowinfra"
 	"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"
 	"github.com/cockroachdb/cockroach/pkg/sql/sessiondata"
-	"github.com/cockroachdb/cockroach/pkg/util/encoding"
 	"github.com/cockroachdb/cockroach/pkg/util/log"
 	"github.com/cockroachdb/errors"
 )
@@ -80,10 +79,11 @@ func insertCPutFn(
 	key *roachpb.Key,
 	value *roachpb.Value,
 	traceKV bool,
-	keyEncodingDirs []encoding.Direction,
+	rh *RowHelper,
+	dirs lazyIndexDirs,
 ) {
 	if traceKV {
-		log.VEventfDepth(ctx, 1, 2, "CPut %s -> %s", keys.PrettyPrint(keyEncodingDirs, *key), value.PrettyPrint())
+		log.VEventfDepth(ctx, 1, 2, "CPut %s -> %s", keys.PrettyPrint(dirs.compute(rh), *key), value.PrettyPrint())
 	}
 	b.CPut(key, value, nil /* expValue */)
 }
@@ -95,10 +95,11 @@ func insertPutFn(
 	key *roachpb.Key,
 	value *roachpb.Value,
 	traceKV bool,
-	keyEncodingDirs []encoding.Direction,
+	rh *RowHelper,
+	dirs lazyIndexDirs,
 ) {
 	if traceKV {
-		log.VEventfDepth(ctx, 1, 2, "Put %s -> %s", keys.PrettyPrint(keyEncodingDirs, *key), value.PrettyPrint())
+		log.VEventfDepth(ctx, 1, 2, "Put %s -> %s", keys.PrettyPrint(dirs.compute(rh), *key), value.PrettyPrint())
 	}
 	b.Put(key, value)
 }
@@ -112,10 +113,11 @@ func insertPutMustAcquireExclusiveLockFn(
 	key *roachpb.Key,
 	value *roachpb.Value,
 	traceKV bool,
-	keyEncodingDirs []encoding.Direction,
+	rh *RowHelper,
+	dirs lazyIndexDirs,
 ) {
 	if traceKV {
-		log.VEventfDepth(ctx, 1, 2, "Put (locking) %s -> %s", keys.PrettyPrint(keyEncodingDirs, *key), value.PrettyPrint())
+		log.VEventfDepth(ctx, 1, 2, "Put (locking) %s -> %s", keys.PrettyPrint(dirs.compute(rh), *key), value.PrettyPrint())
 	}
 	b.PutMustAcquireExclusiveLock(key, value)
 }
@@ -214,7 +216,7 @@ func (ri *Inserter) InsertRow(
 	for idx, index := range ri.Helper.Indexes {
 		entries, ok := secondaryIndexEntries[index]
 		if ok {
-			var putFn func(context.Context, Putter, *roachpb.Key, *roachpb.Value, bool, []encoding.Direction)
+			var putFn func(context.Context, Putter, *roachpb.Key, *roachpb.Value, bool, *RowHelper, lazyIndexDirs)
 			if index.ForcePut() {
 				// See the comment on (catalog.Index).ForcePut() for more
 				// details.
@@ -245,7 +247,7 @@ func (ri *Inserter) InsertRow(
 			}
 			for i := range entries {
 				e := &entries[i]
-				putFn(ctx, b, &e.Key, &e.Value, traceKV, ri.Helper.secIndexValDirs[idx])
+				putFn(ctx, b, &e.Key, &e.Value, traceKV, &ri.Helper, secondaryIndexDirs(idx))
 			}
 
 			// If a row does not satisfy a partial index predicate, it will have no

pkg/sql/row/updater.go

@@ -23,7 +23,6 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/sql/sessiondata"
 	"github.com/cockroachdb/cockroach/pkg/util/buildutil"
 	"github.com/cockroachdb/cockroach/pkg/util/deduplicate"
-	"github.com/cockroachdb/cockroach/pkg/util/encoding"
 	"github.com/cockroachdb/cockroach/pkg/util/intsets"
 	"github.com/cockroachdb/cockroach/pkg/util/log"
 	"github.com/cockroachdb/errors"
@@ -438,7 +437,7 @@ func (ru *Updater) UpdateRow(
 		// putFn and sameKeyPutFn are the functions that should be invoked in
 		// order to write the new k/v entry. If the key doesn't change,
 		// sameKeyPutFn will be used, otherwise putFn will be used.
-		var putFn, sameKeyPutFn func(context.Context, Putter, *roachpb.Key, *roachpb.Value, bool, []encoding.Direction)
+		var putFn, sameKeyPutFn func(context.Context, Putter, *roachpb.Key, *roachpb.Value, bool, *RowHelper, lazyIndexDirs)
 		if index.ForcePut() {
 			// See the comment on (catalog.Index).ForcePut() for more details.
 			// TODO(#140695): re-evaluate the lock need when we enable buffered
@@ -508,7 +507,7 @@ func (ru *Updater) UpdateRow(
 						if err = ru.Helper.deleteIndexEntry(
 							ctx, b, index, &oldEntry.Key, alreadyLocked,
 							ru.Helper.sd.BufferedWritesUseLockingOnNonUniqueIndexes,
-							traceKV, ru.Helper.secIndexValDirs[i],
+							traceKV, secondaryIndexDirs(i),
 						); err != nil {
 							return nil, err
 						}
@@ -528,9 +527,9 @@ func (ru *Updater) UpdateRow(
 					}
 
 					if sameKey {
-						sameKeyPutFn(ctx, b, &newEntry.Key, &newEntry.Value, traceKV, ru.Helper.secIndexValDirs[i])
+						sameKeyPutFn(ctx, b, &newEntry.Key, &newEntry.Value, traceKV, &ru.Helper, secondaryIndexDirs(i))
 					} else {
-						putFn(ctx, b, &newEntry.Key, &newEntry.Value, traceKV, ru.Helper.secIndexValDirs[i])
+						putFn(ctx, b, &newEntry.Key, &newEntry.Value, traceKV, &ru.Helper, secondaryIndexDirs(i))
 					}
 					writtenIndexes.Add(i)
 				} else if oldEntry.Family < newEntry.Family {
@@ -545,7 +544,7 @@ func (ru *Updater) UpdateRow(
 					if err = ru.Helper.deleteIndexEntry(
 						ctx, b, index, &oldEntry.Key, alreadyLocked,
 						ru.Helper.sd.BufferedWritesUseLockingOnNonUniqueIndexes,
-						traceKV, ru.Helper.secIndexValDirs[i],
+						traceKV, secondaryIndexDirs(i),
 					); err != nil {
 						return nil, err
 					}
@@ -560,7 +559,7 @@ func (ru *Updater) UpdateRow(
 
 					// In this case, the index now has a k/v that did not exist
 					// in the old row, so we put the new key in place.
-					putFn(ctx, b, &newEntry.Key, &newEntry.Value, traceKV, ru.Helper.secIndexValDirs[i])
+					putFn(ctx, b, &newEntry.Key, &newEntry.Value, traceKV, &ru.Helper, secondaryIndexDirs(i))
 					writtenIndexes.Add(i)
 					newIdx++
 				}
@@ -574,7 +573,7 @@ func (ru *Updater) UpdateRow(
 				if err = ru.Helper.deleteIndexEntry(
 					ctx, b, index, &oldEntry.Key, alreadyLocked,
 					ru.Helper.sd.BufferedWritesUseLockingOnNonUniqueIndexes,
-					traceKV, ru.Helper.secIndexValDirs[i],
+					traceKV, secondaryIndexDirs(i),
 				); err != nil {
 					return nil, err
 				}
@@ -588,7 +587,7 @@ func (ru *Updater) UpdateRow(
 				// and the old row values do not match the partial index
 				// predicate.
 				newEntry := &newEntries[newIdx]
-				putFn(ctx, b, &newEntry.Key, &newEntry.Value, traceKV, ru.Helper.secIndexValDirs[i])
+				putFn(ctx, b, &newEntry.Key, &newEntry.Value, traceKV, &ru.Helper, secondaryIndexDirs(i))
 				writtenIndexes.Add(i)
 				newIdx++
 			}
@@ -597,14 +596,15 @@ func (ru *Updater) UpdateRow(
 			for j := range ru.oldIndexEntries[i] {
 				if err = ru.Helper.deleteIndexEntry(
 					ctx, b, index, &ru.oldIndexEntries[i][j].Key, alreadyLocked,
-					ru.Helper.sd.BufferedWritesUseLockingOnNonUniqueIndexes, traceKV, nil, /* valDirs */
+					ru.Helper.sd.BufferedWritesUseLockingOnNonUniqueIndexes, traceKV, emptyIndexDirs,
 				); err != nil {
 					return nil, err
 				}
 			}
 			// We're adding all of the inverted index entries from the row being updated.
 			for j := range ru.newIndexEntries[i] {
-				putFn(ctx, b, &ru.newIndexEntries[i][j].Key, &ru.newIndexEntries[i][j].Value, traceKV, ru.Helper.secIndexValDirs[i])
+				putFn(ctx, b, &ru.newIndexEntries[i][j].Key, &ru.newIndexEntries[i][j].Value, traceKV,
+					&ru.Helper, secondaryIndexDirs(i))
 			}
 		}
 	}
@@ -631,7 +631,7 @@ func (ru *Updater) UpdateRow(
 				for _, deletedSecondaryIndexEntry := range deletedSecondaryIndexEntries {
 					if err = ru.DeleteHelper.deleteIndexEntry(
 						ctx, b, index, &deletedSecondaryIndexEntry.Key, alreadyLocked,
-						ru.Helper.sd.BufferedWritesUseLockingOnNonUniqueIndexes, traceKV, nil, /* valDirs */
+						ru.Helper.sd.BufferedWritesUseLockingOnNonUniqueIndexes, traceKV, emptyIndexDirs,
 					); err != nil {
 						return nil, err
 					}
@@ -671,11 +671,12 @@ func updateCPutFn(
 	value *roachpb.Value,
 	expVal []byte,
 	traceKV bool,
-	keyEncodingDirs []encoding.Direction,
+	rh *RowHelper,
+	dirs lazyIndexDirs,
 ) {
 	if traceKV {
 		log.VEventfDepth(
-			ctx, 1, 2, "CPut %s -> %s (swap)", keys.PrettyPrint(keyEncodingDirs, *key),
+			ctx, 1, 2, "CPut %s -> %s (swap)", keys.PrettyPrint(dirs.compute(rh), *key),
 			value.PrettyPrint(),
 		)
 	}