sql,optbuilder: route descriptor lookups for triggers through cache

Triggers have a `TG_TABLE_SCHEMA` argument which provides the schema
name. Getting the schema name requires doing a descriptor lookup when
the trigger is planned, which previously avoided the cache and always
performed an expensive KV lookup. This commit plumbs `ResolveSchemaByID`,
which allows the lookup to hit the descriptor cache.

Fixes #144211

Release note (performance improvement): Triggers now perform the
descriptor lookup for `TG_TABLE_SCHEMA` against a cache. This can
significantly reduce trigger planning latency in multi-region databases.

Author: DrewKimball

pkg/bench/rttanalysis/testdata/benchmark_expectations

@@ -119,7 +119,7 @@ exp,benchmark
 1,SystemDatabaseQueries/select_system.users_with_empty_database_Name
 1,SystemDatabaseQueries/select_system.users_with_schema_Name
 1,SystemDatabaseQueries/select_system.users_without_schema_Name
-3,TriggerResolution/insert_into_table_with_trigger
+1,TriggerResolution/insert_into_table_with_trigger
 15,Truncate/truncate_1_column_0_rows
 15,Truncate/truncate_1_column_1_row
 15,Truncate/truncate_1_column_2_rows

pkg/sql/opt/cat/catalog.go

@@ -153,6 +153,10 @@ type Catalog interface {
 	// be safely copied or used across goroutines.
 	ResolveSchema(ctx context.Context, flags Flags, name *SchemaName) (Schema, SchemaName, error)
 
+	// ResolveSchemaByID is similar to ResolveSchema, except that it locates a
+	// schema by its StableID. See the comment for StableID for more details.
+	ResolveSchemaByID(ctx context.Context, flags Flags, id StableID) (Schema, error)
+
 	// GetAllSchemaNamesForDB Gets all the SchemaNames for a database.
 	GetAllSchemaNamesForDB(ctx context.Context, dbName string) ([]SchemaName, error)
 

pkg/sql/opt/cat/table.go

@@ -175,6 +175,10 @@ type Table interface {
 	// owning database could not be determined.
 	GetDatabaseID() descpb.ID
 
+	// GetSchemaID returns the owning schema id of the table, or zero, if the
+	// owning schema could not be determined.
+	GetSchemaID() descpb.ID
+
 	// IsHypothetical returns true if this is a hypothetical table (used when
 	// searching for index recommendations).
 	IsHypothetical() bool

pkg/sql/opt/exec/explain/plan_gist_factory.go

@@ -650,6 +650,11 @@ func (u *unknownTable) GetDatabaseID() descpb.ID {
 	return 0
 }
 
+// GetSchemaID is part of the cat.Table interface.
+func (u *unknownTable) GetSchemaID() descpb.ID {
+	return 0
+}
+
 // IsHypothetical is part of the cat.Table interface.
 func (u *unknownTable) IsHypothetical() bool {
 	return false

pkg/sql/opt/optbuilder/trigger.go

@@ -220,11 +220,13 @@ func (mb *mutationBuilder) buildTriggerFunctionArgs(
 	tgOp := tree.NewDString(eventType.String())
 	tgRelID := tree.NewDOid(oid.Oid(mb.tab.ID()))
 	tgTableName := tree.NewDString(string(mb.tab.Name()))
-	fqName, err := mb.b.catalog.FullyQualifiedName(mb.b.ctx, mb.tab)
+	schema, err := mb.b.catalog.ResolveSchemaByID(
+		mb.b.ctx, cat.Flags{}, cat.StableID(mb.tab.GetSchemaID()),
+	)
 	if err != nil {
 		panic(err)
 	}
-	tgTableSchema := tree.NewDString(fqName.Schema())
+	tgTableSchema := tree.NewDString(schema.Name().Schema())
 	tgNumArgs := tree.NewDInt(tree.DInt(len(trigger.FuncArgs())))
 	tgArgV := tree.NewDArray(types.String)
 	for _, arg := range trigger.FuncArgs() {

pkg/sql/opt/testutils/testcat/create_table.go

@@ -80,7 +80,7 @@ func (tc *Catalog) CreateTable(stmt *tree.CreateTable) *Table {
 		isRbr = stmt.Locality.LocalityLevel == tree.LocalityLevelRow
 		isRbt = stmt.Locality.LocalityLevel == tree.LocalityLevelTable
 	}
-	tab := &Table{TabID: tc.nextStableID(), TabName: stmt.Table, Catalog: tc}
+	tab := &Table{TabID: tc.nextStableID(), SchemaID: testSchemaID, TabName: stmt.Table, Catalog: tc}
 
 	if isRbt && stmt.Locality.TableRegion != "" {
 		tab.multiRegion = true
@@ -490,7 +490,13 @@ func (tc *Catalog) CreateTableAs(name tree.TableName, columns []cat.Column) *Tab
 	// Update the table name to include catalog and schema if not provided.
 	tc.qualifyTableName(&name)
 
-	tab := &Table{TabID: tc.nextStableID(), TabName: name, Catalog: tc, Columns: columns}
+	tab := &Table{
+		TabID:    tc.nextStableID(),
+		SchemaID: testSchemaID,
+		TabName:  name,
+		Catalog:  tc,
+		Columns:  columns,
+	}
 
 	var rowid cat.Column
 	ordinal := len(columns)

pkg/sql/opt/testutils/testcat/test_catalog.go

@@ -43,7 +43,8 @@ import (
 
 const (
 	// testDB is the default current database for testing purposes.
-	testDB = "t"
+	testDB       = "t"
+	testSchemaID = 1
 )
 
 // Catalog implements the cat.Catalog interface for testing purposes.
@@ -78,7 +79,7 @@ func New() *Catalog {
 
 	return &Catalog{
 		testSchema: Schema{
-			SchemaID: 1,
+			SchemaID: testSchemaID,
 			SchemaName: cat.SchemaName{
 				CatalogName:     testDB,
 				SchemaName:      catconstants.PublicSchemaName,
@@ -135,6 +136,17 @@ func (tc *Catalog) ResolveSchema(
 	return tc.resolveSchema(&toResolve)
 }
 
+// ResolveSchemaByID is part of the cat.Catalog interface.
+func (tc *Catalog) ResolveSchemaByID(
+	_ context.Context, _ cat.Flags, id cat.StableID,
+) (cat.Schema, error) {
+	if id != testSchemaID {
+		return nil, pgerror.Newf(pgcode.InvalidSchemaName,
+			"target database or schema does not exist")
+	}
+	return &tc.testSchema, nil
+}
+
 // GetAllSchemaNamesForDB is part of the cat.Catalog interface.
 func (tc *Catalog) GetAllSchemaNamesForDB(
 	ctx context.Context, dbName string,
@@ -844,6 +856,7 @@ func (tv *View) Trigger(i int) cat.Trigger {
 type Table struct {
 	TabID      cat.StableID
 	DatabaseID descpb.ID
+	SchemaID   descpb.ID
 	TabVersion int
 	TabName    tree.TableName
 	Columns    []cat.Column
@@ -1085,6 +1098,11 @@ func (tt *Table) GetDatabaseID() descpb.ID {
 	return tt.DatabaseID
 }
 
+// GetSchemaID is part of the cat.Table interface.
+func (tt *Table) GetSchemaID() descpb.ID {
+	return tt.SchemaID
+}
+
 // IsHypothetical is part of the cat.Table interface.
 func (tt *Table) IsHypothetical() bool {
 	return false

pkg/sql/opt_catalog.go

@@ -183,6 +183,32 @@ func (oc *optCatalog) LookupDatabaseName(
 	return tree.Name(name), nil
 }
 
+func (oc *optCatalog) ResolveSchemaByID(
+	ctx context.Context, flags cat.Flags, schemaID cat.StableID,
+) (cat.Schema, error) {
+	if flags.AvoidDescriptorCaches {
+		defer func(prev bool) {
+			oc.planner.skipDescriptorCache = prev
+		}(oc.planner.skipDescriptorCache)
+		oc.planner.skipDescriptorCache = true
+	}
+
+	schemaLookup, err := oc.planner.LookupSchemaByID(ctx, descpb.ID(schemaID))
+	if err != nil {
+		return nil, err
+	}
+	databaseLookup, err := oc.planner.LookupDatabaseByID(ctx, schemaLookup.GetParentID())
+	if err != nil {
+		return nil, err
+	}
+	return &optSchema{
+		planner:  oc.planner,
+		database: databaseLookup,
+		schema:   schemaLookup,
+		name:     oc.tn.ObjectNamePrefix,
+	}, nil
+}
+
 // ResolveSchema is part of the cat.Catalog interface.
 func (oc *optCatalog) ResolveSchema(
 	ctx context.Context, flags cat.Flags, name *cat.SchemaName,
@@ -1523,6 +1549,11 @@ func (ot *optTable) GetDatabaseID() descpb.ID {
 	return ot.desc.GetParentID()
 }
 
+// GetSchemaID is part of the cat.Table interface.
+func (ot *optTable) GetSchemaID() descpb.ID {
+	return ot.desc.GetParentSchemaID()
+}
+
 // IsHypothetical is part of the cat.Table interface.
 func (ot *optTable) IsHypothetical() bool {
 	return false
@@ -2639,6 +2670,11 @@ func (ot *optVirtualTable) GetDatabaseID() descpb.ID {
 	return 0
 }
 
+// GetSchemaID is part of the cat.Table interface.
+func (ot *optVirtualTable) GetSchemaID() descpb.ID {
+	return ot.desc.GetParentSchemaID()
+}
+
 // IsHypothetical is part of the cat.Table interface.
 func (ot *optVirtualTable) IsHypothetical() bool {
 	return false

pkg/sql/planner.go

@@ -741,8 +741,7 @@ func (p *planner) CheckPrivilegeForTableID(
 	return p.CheckPrivilegeForUser(ctx, desc, privilege, p.User())
 }
 
-// LookupTableByID looks up a table, by the given descriptor ID. Based on the
-// CommonLookupFlags, it could use or skip the Collection cache.
+// LookupTableByID looks up a table, by the given descriptor ID.
 func (p *planner) LookupTableByID(
 	ctx context.Context, tableID descpb.ID,
 ) (catalog.TableDescriptor, error) {
@@ -753,6 +752,28 @@ func (p *planner) LookupTableByID(
 	return table, nil
 }
 
+// LookupSchemaByID looks up a schema by the given descriptor ID.
+func (p *planner) LookupSchemaByID(
+	ctx context.Context, schemaID descpb.ID,
+) (catalog.SchemaDescriptor, error) {
+	schema, err := p.byIDGetterBuilder().WithoutNonPublic().Get().Schema(ctx, schemaID)
+	if err != nil {
+		return nil, err
+	}
+	return schema, nil
+}
+
+// LookupDatabaseByID looks up a database by the given descriptor ID.
+func (p *planner) LookupDatabaseByID(
+	ctx context.Context, databaseID descpb.ID,
+) (catalog.DatabaseDescriptor, error) {
+	database, err := p.byIDGetterBuilder().WithoutNonPublic().Get().Database(ctx, databaseID)
+	if err != nil {
+		return nil, err
+	}
+	return database, nil
+}
+
 // SessionData is part of the PlanHookState interface.
 func (p *planner) SessionData() *sessiondata.SessionData {
 	return p.EvalContext().SessionData()