typedesc: avoid slice copy when hydrating enums

A profile showed that when an enum has a lot of values, hydrating it can
become expensive since it requires initializing a large slice.

Since these objects are immutable, we can just reference the slice
directly.

```
goos: darwin
goarch: arm64
                    │   bench-old   │              bench-new              │
                    │    sec/op     │    sec/op     vs base               │
ResolveTypeByOID-10   106.266µ ± 4%   1.246µ ± 14%  -98.83% (p=0.002 n=6)

                    │   bench-old   │             bench-new             │
                    │     B/op      │    B/op     vs base               │
ResolveTypeByOID-10   422992.5 ± 0%   453.0 ± 0%  -99.89% (p=0.002 n=6)

                    │ bench-old  │             bench-new             │
                    │ allocs/op  │ allocs/op   vs base               │
ResolveTypeByOID-10   51.00 ± 4%   12.00 ± 0%  -76.47% (p=0.002 n=6)
```

Release note (performance improvement): Improved the cost of resolving a
user-defined enum type that has many values.

pkg/sql/catalog/typedesc/hydrate.go

@@ -137,16 +137,26 @@ func ensureTypeMetadataIsHydrated(
 		return
 	}
 	if e := maybeDesc.AsEnumTypeDescriptor(); e != nil {
-		n := e.NumEnumMembers()
-		tm.EnumData = &types.EnumMetadata{
-			LogicalRepresentations:  make([]string, n),
-			PhysicalRepresentations: make([][]byte, n),
-			IsMemberReadOnly:        make([]bool, n),
-		}
-		for i := 0; i < n; i++ {
-			tm.EnumData.LogicalRepresentations[i] = e.GetMemberLogicalRepresentation(i)
-			tm.EnumData.PhysicalRepresentations[i] = e.GetMemberPhysicalRepresentation(i)
-			tm.EnumData.IsMemberReadOnly[i] = e.IsMemberReadOnly(i)
+		if imm, ok := e.(*immutable); ok {
+			// Fast-path for immutable enum descriptors. We can use a pointer into the
+			// immutable descriptor's slices, since the TypMetadata is immutable too.
+			tm.EnumData = &types.EnumMetadata{
+				LogicalRepresentations:  imm.logicalReps,
+				PhysicalRepresentations: imm.physicalReps,
+				IsMemberReadOnly:        imm.readOnlyMembers,
+			}
+		} else {
+			n := e.NumEnumMembers()
+			tm.EnumData = &types.EnumMetadata{
+				LogicalRepresentations:  make([]string, n),
+				PhysicalRepresentations: make([][]byte, n),
+				IsMemberReadOnly:        make([]bool, n),
+			}
+			for i := 0; i < n; i++ {
+				tm.EnumData.LogicalRepresentations[i] = e.GetMemberLogicalRepresentation(i)
+				tm.EnumData.PhysicalRepresentations[i] = e.GetMemberPhysicalRepresentation(i)
+				tm.EnumData.IsMemberReadOnly[i] = e.IsMemberReadOnly(i)
+			}
 		}
 	}
 }

pkg/sql/schema_resolver_test.go

@@ -52,10 +52,10 @@ func BenchmarkResolveTypeByOID(b *testing.B) {
 
 	ctx := context.Background()
 	execCfg := s.ExecutorConfig().(ExecutorConfig)
-	sd := NewInternalSessionData(ctx, execCfg.Settings, "test")
+	sd := NewFakeSessionData(&execCfg.Settings.SV, "test")
 	sd.Database = "defaultdb"
 	planner, cleanup := newInternalPlanner("test", kv.NewTxn(ctx, kvDB, s.NodeID()),
-		username.RootUserName(), &MemoryMetrics{}, &execCfg, sd,
+		username.RootUserName(), &MemoryMetrics{}, &execCfg, sd.SessionData,
 	)
 	defer cleanup()