Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
fix(parser/tidb): surface ResourceNotFoundError on QuerySpan for resync recovery (#20387)
h3n4ld5f6842ea10f
diff --git a/backend/plugin/parser/tidb/query_span_extractor.go b/backend/plugin/parser/tidb/query_span_extractor.goindex 9988195b2f..f7c1e35699 100644--- a/backend/plugin/parser/tidb/query_span_extractor.go+++ b/backend/plugin/parser/tidb/query_span_extractor.go@@ -74,6 +74,27 @@ func (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string)tableSource, err := q.extractTableSourceFromNode(node)if err != nil {+ // Surface ResourceNotFoundError on the span so the SQL service can resync stale metadata and retry.+ var resourceNotFound *base.ResourceNotFoundError+ if errors.As(err, &resourceNotFound) {+ sourceColumns := make(base.SourceColumnSet, len(accessTables)+1)+ for k := range accessTables {+ sourceColumns[k] = true+ }+ // Add the not-found target only when it carries a distinct ACL/resync anchor.+ // For unqualified column-not-found, target.Table is empty and the FROM tables+ // in accessTables already provide the right table-level ACL keys, so skip.+ target := notFoundSyncTarget(resourceNotFound, q.defaultDatabase)+ if len(sourceColumns) == 0 || target.Table != "" {+ sourceColumns[target] = true+ }+ return &base.QuerySpan{+ Type: queryType,+ Results: []base.QuerySpanResult{},+ SourceColumns: sourceColumns,+ NotFoundError: resourceNotFound,+ }, nil+ }return nil, err}if tableSource == nil {@@ -91,6 +112,24 @@ func (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string)}, nil}+// notFoundSyncTarget derives a sync target for the resync loop, falling back to defaultDatabase when the error lacks one.+func notFoundSyncTarget(e *base.ResourceNotFoundError, defaultDatabase string) base.ColumnResource {+ r := base.ColumnResource{Database: defaultDatabase}+ if e.Database != nil && *e.Database != "" {+ r.Database = *e.Database+ }+ if e.Schema != nil {+ r.Schema = *e.Schema+ }+ if e.Table != nil {+ r.Table = *e.Table+ }+ if e.Column != nil {+ r.Column = *e.Column+ }+ return r+}+func skipQuerySpan(node tidbast.Node, queryType base.QueryType) bool {if queryType == base.Select {return falsediff --git a/backend/plugin/parser/tidb/query_span_test.go b/backend/plugin/parser/tidb/query_span_test.goindex fbb145e37a..61b6c30758 100644--- a/backend/plugin/parser/tidb/query_span_test.go+++ b/backend/plugin/parser/tidb/query_span_test.go@@ -74,6 +74,163 @@ func TestGetQuerySpan(t *testing.T) {}}+// When a referenced column is missing from cached metadata, the extractor must+// surface ResourceNotFoundError on the span (not as a top-level error) so the+// SQL service's resync+retry path can recover.+func TestGetQuerySpanStaleMetadataReturnsNotFoundError(t *testing.T) {+ a := require.New(t)++ // Metadata omits distribute_level to mimic a stale cache after out-of-band ALTER TABLE ADD COLUMN.+ staleMetadata := &storepb.DatabaseSchemaMetadata{+ Name: "cif",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "",+ Tables: []*storepb.TableMetadata{+ {+ Name: "byt9385_repro",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id"},+ {Name: "existing_col"},+ {Name: "create_time"},+ },+ },+ },+ },+ },+ }+ databaseMetadataGetter, databaseNamesLister := buildMockDatabaseMetadataGetter([]*storepb.DatabaseSchemaMetadata{staleMetadata})++ span, err := GetQuerySpan(+ context.TODO(),+ base.GetQuerySpanContext{+ GetDatabaseMetadataFunc: databaseMetadataGetter,+ ListDatabaseNamesFunc: databaseNamesLister,+ },+ base.Statement{Text: "SELECT distribute_level FROM byt9385_repro ORDER BY create_time DESC"},+ "cif",+ "",+ false,+ )+ a.NoError(err, "expected stale-metadata case to return a span, not a wrapped error")+ a.NotNil(span)+ a.NotNil(span.NotFoundError, "stale-metadata case must populate span.NotFoundError so sql_service can resync+retry")++ var resourceNotFound *base.ResourceNotFoundError+ a.True(errors.As(span.NotFoundError, &resourceNotFound))+ a.NotNil(resourceNotFound.Column)+ a.Equal("distribute_level", *resourceNotFound.Column)++ // SourceColumns must reference the FROM table so sql_service knows which database to resync.+ foundTable := false+ for k := range span.SourceColumns {+ if k.Database == "cif" && k.Table == "byt9385_repro" {+ foundTable = true+ }+ // optionalAccessCheck validates every SourceColumns entry against table-scoped+ // CEL policies; a synthesized table-less entry would deny least-privilege users+ // on the recovery path even when the FROM table is already authorized.+ a.NotEmpty(k.Table, "SourceColumns must not contain table-less entries when the FROM table is known: got %+v", k)+ }+ a.True(foundTable, "span.SourceColumns must reference the FROM table for resync to target the right database")+}++// When the referenced table is missing from cached metadata, accessTables is+// empty; SourceColumns must still expose a sync target so resync+retry can run.+func TestGetQuerySpanMissingTableFallsBackToNotFoundDatabase(t *testing.T) {+ a := require.New(t)++ // Metadata is missing the table entirely.+ staleMetadata := &storepb.DatabaseSchemaMetadata{+ Name: "cif",+ Schemas: []*storepb.SchemaMetadata{+ {Name: "", Tables: []*storepb.TableMetadata{}},+ },+ }+ databaseMetadataGetter, databaseNamesLister := buildMockDatabaseMetadataGetter([]*storepb.DatabaseSchemaMetadata{staleMetadata})++ span, err := GetQuerySpan(+ context.TODO(),+ base.GetQuerySpanContext{+ GetDatabaseMetadataFunc: databaseMetadataGetter,+ ListDatabaseNamesFunc: databaseNamesLister,+ },+ base.Statement{Text: "SELECT name FROM byt9385_caseB"},+ "cif",+ "",+ false,+ )+ a.NoError(err)+ a.NotNil(span)+ a.NotNil(span.NotFoundError, "missing-table case must populate span.NotFoundError")++ var resourceNotFound *base.ResourceNotFoundError+ a.True(errors.As(span.NotFoundError, &resourceNotFound))+ a.NotNil(resourceNotFound.Table)+ a.Equal("byt9385_caseB", *resourceNotFound.Table)++ a.NotEmpty(span.SourceColumns, "SourceColumns must not be empty — sql_service iterates it to build the resync target list")+ foundDatabase := false+ for k := range span.SourceColumns {+ if k.Database == "cif" {+ foundDatabase = true+ break+ }+ }+ a.True(foundDatabase, "resync target must reference the database where the missing table lives")+}++// SourceColumns must include the not-found target alongside known tables — the+// pre-execute ACL check isn't rerun after resync+retry, so dropping the missing+// resource would let an out-of-band CREATE TABLE bypass table-level ACL.+func TestGetQuerySpanMissingTableUnionedWithAccessTables(t *testing.T) {+ a := require.New(t)++ // Metadata has the "known" table but not the "unknown" one.+ staleMetadata := &storepb.DatabaseSchemaMetadata{+ Name: "cif",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "",+ Tables: []*storepb.TableMetadata{+ {+ Name: "byt9385_known",+ Columns: []*storepb.ColumnMetadata{{Name: "a"}},+ },+ },+ },+ },+ }+ databaseMetadataGetter, databaseNamesLister := buildMockDatabaseMetadataGetter([]*storepb.DatabaseSchemaMetadata{staleMetadata})++ span, err := GetQuerySpan(+ context.TODO(),+ base.GetQuerySpanContext{+ GetDatabaseMetadataFunc: databaseMetadataGetter,+ ListDatabaseNamesFunc: databaseNamesLister,+ },+ base.Statement{Text: "SELECT a FROM byt9385_known UNION SELECT a FROM byt9385_unknown"},+ "cif",+ "",+ false,+ )+ a.NoError(err)+ a.NotNil(span)+ a.NotNil(span.NotFoundError)++ foundKnown, foundUnknown := false, false+ for k := range span.SourceColumns {+ if k.Database == "cif" && k.Table == "byt9385_known" {+ foundKnown = true+ }+ if k.Database == "cif" && k.Table == "byt9385_unknown" {+ foundUnknown = true+ }+ }+ a.True(foundKnown, "known table must remain in SourceColumns")+ a.True(foundUnknown, "not-found table must be unioned into SourceColumns so the pre-execute ACL check sees it")+}+func buildMockDatabaseMetadataGetter(databaseMetadata []*storepb.DatabaseSchemaMetadata) (base.GetDatabaseMetadataFunc, base.ListDatabaseNamesFunc) {return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {m := make(map[string]*model.DatabaseMetadata)