cli: add lock table key support to debug decode-key

The debug decode-key command previously only supported MVCC keys
and unversioned user keys. This change adds support for decoding
lock table keys by using DecodeEngineKey to determine key type
and handling lock table keys with ToLockTableKey().

Test cases added for both Intent and Shared lock strengths.

Fixes: #114425

Release Notes: None

Author: vishalv1994

pkg/cli/BUILD.bazel

@@ -420,6 +420,7 @@ go_test(
         "//pkg/kv/kvclient/kvtenant",
         "//pkg/kv/kvpb",
         "//pkg/kv/kvserver",
+        "//pkg/kv/kvserver/concurrency/lock",
         "//pkg/kv/kvserver/liveness",
         "//pkg/kv/kvserver/liveness/livenesspb",
         "//pkg/kv/kvserver/loqrecovery",
@@ -456,6 +457,7 @@ go_test(
         "//pkg/ts/tspb",
         "//pkg/util",
         "//pkg/util/envutil",
+        "//pkg/util/hlc",
         "//pkg/util/ioctx",
         "//pkg/util/leaktest",
         "//pkg/util/log",

pkg/cli/debug.go

@@ -660,11 +660,35 @@ For example:
 			if decodeKeyOptions.userKey {
 				fmt.Println(roachpb.Key(b))
 			} else {
-				k, err := storage.DecodeMVCCKey(b)
-				if err != nil {
-					return err
+				// Try to decode as an EngineKey first to determine the key type.
+				engineKey, ok := storage.DecodeEngineKey(b)
+				if ok {
+					if engineKey.IsLockTableKey() {
+						// Decode as a lock table key.
+						lockKey, err := engineKey.ToLockTableKey()
+						if err != nil {
+							return err
+						}
+						fmt.Println(lockKey)
+					} else if engineKey.IsMVCCKey() {
+						// Decode as an MVCC key.
+						mvccKey, err := engineKey.ToMVCCKey()
+						if err != nil {
+							return err
+						}
+						fmt.Println(mvccKey)
+					} else {
+						// Print the engine key as-is.
+						fmt.Println(engineKey)
+					}
+				} else {
+					// Fall back to trying MVCC key decoding for backwards compatibility.
+					k, err := storage.DecodeMVCCKey(b)
+					if err != nil {
+						return err
+					}
+					fmt.Println(k)
 				}
-				fmt.Println(k)
 			}
 		}
 		return nil

pkg/cli/debug_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/base"
 	"github.com/cockroachdb/cockroach/pkg/clusterversion"
 	"github.com/cockroachdb/cockroach/pkg/gossip"
+	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/concurrency/lock"
 	"github.com/cockroachdb/cockroach/pkg/roachpb"
 	"github.com/cockroachdb/cockroach/pkg/server"
 	"github.com/cockroachdb/cockroach/pkg/settings/cluster"
@@ -25,9 +26,11 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/testutils"
 	"github.com/cockroachdb/cockroach/pkg/testutils/serverutils"
 	"github.com/cockroachdb/cockroach/pkg/testutils/testcluster"
+	"github.com/cockroachdb/cockroach/pkg/util/hlc"
 	"github.com/cockroachdb/cockroach/pkg/util/leaktest"
 	"github.com/cockroachdb/cockroach/pkg/util/log"
 	"github.com/cockroachdb/cockroach/pkg/util/stop"
+	"github.com/cockroachdb/cockroach/pkg/util/uuid"
 )
 
 func createStore(t *testing.T, path string) {
@@ -136,3 +139,110 @@ func TestParsePositiveDuration(t *testing.T) {
 		t.Errorf("Expected to fail parsing negative duration -5m")
 	}
 }
+
+// TestDebugDecodeKeyEngineKeyPaths tests the new engine key decoding logic in debug.go
+func TestDebugDecodeKeyEngineKeyPaths(t *testing.T) {
+	defer leaktest.AfterTest(t)()
+	defer log.Scope(t).Close(t)
+
+	t.Run("lock_table_keys", func(t *testing.T) {
+		// Create lock table keys and test they decode properly
+		uuid1 := uuid.Must(uuid.FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8"))
+
+		lockKeys := []storage.LockTableKey{
+			{Key: roachpb.Key("test"), Strength: lock.Shared, TxnUUID: uuid1},
+			{Key: roachpb.Key("foo"), Strength: lock.Exclusive, TxnUUID: uuid1},
+			{Key: roachpb.Key("bar"), Strength: lock.Intent, TxnUUID: uuid1},
+		}
+
+		for i, lockKey := range lockKeys {
+			t.Run(fmt.Sprintf("lock_%d_%s", i, lockKey.Strength), func(t *testing.T) {
+				engineKey, _ := lockKey.ToEngineKey(nil)
+				encoded := engineKey.Encode()
+				hexKey := fmt.Sprintf("%x", encoded)
+
+				out, err := TestCLI{}.RunWithCaptureArgs([]string{
+					"debug", "decode-key", "--encoding", "hex", hexKey,
+				})
+
+				if err != nil {
+					t.Fatalf("Unexpected error: %v", err)
+				}
+
+				// Verify the output contains lock strength and key
+				if !strings.Contains(out, lockKey.Strength.String()) {
+					t.Errorf("Expected output to contain lock strength %s, got: %s", lockKey.Strength, out)
+				}
+				if !strings.Contains(out, string(lockKey.Key)) {
+					t.Errorf("Expected output to contain key %s, got: %s", lockKey.Key, out)
+				}
+			})
+		}
+	})
+
+	t.Run("mvcc_keys_via_engine_key", func(t *testing.T) {
+		// Test MVCC keys that are decoded via the EngineKey.IsMVCCKey() path
+		mvccKey := storage.MVCCKey{
+			Key:       roachpb.Key("mvcc_test"),
+			Timestamp: hlc.Timestamp{WallTime: 123456},
+		}
+
+		encoded := storage.EncodeMVCCKey(mvccKey)
+		hexKey := fmt.Sprintf("%x", encoded)
+
+		out, err := TestCLI{}.RunWithCaptureArgs([]string{
+			"debug", "decode-key", "--encoding", "hex", hexKey,
+		})
+
+		if err != nil {
+			t.Fatalf("Unexpected error: %v", err)
+		}
+
+		if !strings.Contains(out, "mvcc_test") {
+			t.Errorf("Expected output to contain key content, got: %s", out)
+		}
+	})
+
+	t.Run("engine_key_other_types", func(t *testing.T) {
+		// Test engine keys that are neither lock table nor MVCC keys
+		// These should be printed as-is via the "else" branch
+		// For now, we'll test with a simple case that should trigger this path
+
+		// This will test the fallback path when DecodeEngineKey returns false
+		invalidEngineKey := "ff"
+
+		out, err := TestCLI{}.RunWithCaptureArgs([]string{
+			"debug", "decode-key", "--encoding", "hex", invalidEngineKey,
+		})
+
+		if err != nil {
+			t.Fatalf("Unexpected error: %v", err)
+		}
+
+		// Should trigger the MVCC fallback path and show an error
+		if !strings.Contains(out, "ERROR") {
+			t.Errorf("Expected output to contain error from MVCC fallback, got: %s", out)
+		}
+	})
+
+	t.Run("backwards_compatibility_fallback", func(t *testing.T) {
+		// Test the fallback path: when DecodeEngineKey fails,
+		// it should fall back to DecodeMVCCKey for backwards compatibility
+
+		// Use the same test case from existing tests that should trigger fallback
+		invalidKey := "jg==" // base64 encoded "8e"
+
+		out, err := TestCLI{}.RunWithCaptureArgs([]string{
+			"debug", "decode-key", "--encoding", "base64", invalidKey,
+		})
+
+		if err != nil {
+			t.Fatalf("Unexpected error: %v", err)
+		}
+
+		// Should contain error message from MVCC key decoding fallback
+		if !strings.Contains(out, "ERROR: invalid encoded mvcc key") {
+			t.Errorf("Expected fallback to MVCC decoding with error message, got: %s", out)
+		}
+	})
+}