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: add public to search path (#20770)
ecmadao2f9eda842054
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.goindex 387375552c..d91d479132 100644--- a/backend/api/v1/sql_service.go+++ b/backend/api/v1/sql_service.go@@ -1943,8 +1943,12 @@ func (s *SQLService) resolveWriteTargets(return nil, nil}+ targetSchema := schemaForWriteTargetResolution(engine, database.DatabaseName, requestSchema)+ if engine == storepb.Engine_POSTGRES {+ targetSchema = postgresWriteTargetSchemaForRequest(requestSchema, dbMeta)+ }changeSummary, err := parserbase.ExtractChangedResources(- engine, database.DatabaseName, schemaForWriteTargetResolution(engine, database.DatabaseName, requestSchema), dbMeta, asts, statement,+ engine, database.DatabaseName, targetSchema, dbMeta, asts, statement,)if err != nil || changeSummary == nil || changeSummary.ChangedResources == nil {//nolint:nilerr // unsupported engine / no result → fall back to database-level check@@ -2002,8 +2006,8 @@ const unresolvedSchemaSentinel = "\x00bb_unresolved_schema\x00"func schemaForWriteTargetResolution(engine storepb.Engine, databaseName, requestSchema string) string {switch engine {case storepb.Engine_POSTGRES:- // Execution pins search_path to QueryRequest.schema when set; otherwise the- // connection user's default ($user, public) is not knowable here.+ // Execution uses QueryRequest.schema first when set; otherwise the connection+ // user's default ($user, public) is not knowable here.if requestSchema != "" {return requestSchema}@@ -2033,6 +2037,16 @@ func schemaForWriteTargetResolution(engine storepb.Engine, databaseName, request}}+func postgresWriteTargetSchemaForRequest(requestSchema string, dbMeta *model.DatabaseMetadata) string {+ if requestSchema == "" {+ return unresolvedSchemaSentinel+ }+ if dbMeta.GetSchemaMetadata(requestSchema) != nil {+ return requestSchema+ }+ return unresolvedSchemaSentinel+}+// sanitizeResults sanitizes the strings in the results by replacing all the invalid UTF-8 characters with its hexadecimal representation.func sanitizeResults(results []*v1pb.QueryResult) {for _, result := range results {diff --git a/backend/api/v1/sql_service_schema_resolution_test.go b/backend/api/v1/sql_service_schema_resolution_test.goindex d790e24a01..22cdb95bba 100644--- a/backend/api/v1/sql_service_schema_resolution_test.go+++ b/backend/api/v1/sql_service_schema_resolution_test.go@@ -6,6 +6,7 @@ import ("github.com/stretchr/testify/require"storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store/model")// TestSchemaForWriteTargetResolution pins the per-engine default schema used to resolve@@ -41,6 +42,31 @@ func TestSchemaForWriteTargetResolution(t *testing.T) {}}+func TestPostgresWriteTargetSchemaForRequest(t *testing.T) {+ dbMeta := model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Schemas: []*storepb.SchemaMetadata{+ {Name: "app"},+ {Name: "public"},+ },+ }, []byte{}, &storepb.DatabaseConfig{}, storepb.Engine_POSTGRES, true /* caseSensitive */)++ tests := []struct {+ name string+ requestSchema string+ want string+ }{+ {"selected schema exists", "app", "app"},+ {"selected public schema exists", "public", "public"},+ {"selected schema is missing", "missing", unresolvedSchemaSentinel},+ {"empty selected schema is unknowable", "", unresolvedSchemaSentinel},+ }+ for _, tc := range tests {+ t.Run(tc.name, func(t *testing.T) {+ require.Equal(t, tc.want, postgresWriteTargetSchemaForRequest(tc.requestSchema, dbMeta))+ })+ }+}+// TestUnresolvedSchemaSentinelIsImpossible guards that the sentinel can never collide with a// real schema: a NUL byte is not representable in a PostgreSQL/MSSQL identifier.func TestUnresolvedSchemaSentinelIsImpossible(t *testing.T) {diff --git a/backend/plugin/db/pg/pg.go b/backend/plugin/db/pg/pg.goindex 0960027398..558228f186 100644--- a/backend/plugin/db/pg/pg.go+++ b/backend/plugin/db/pg/pg.go@@ -809,11 +809,13 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string}// Sanitize the schema name by escaping any quotes.- safeSchemeName := strings.ReplaceAll(queryContext.Schema, "\"", "\"\"")+ safeSchemaName := strings.ReplaceAll(queryContext.Schema, "\"", "\"\"")// If the queryContext.Schema is not empty, set the search path for the database connection to the specified schema.+ // Keep public in the path because PostgreSQL extensions commonly install functions there, and their+ // function bodies may call helper functions without schema qualification.if queryContext.Schema != "" {- if _, err := conn.ExecContext(ctx, fmt.Sprintf(`SET search_path TO "%s";`, safeSchemeName)); err != nil { // NOSONAR(go:S2077) safeSchemeName is sanitized via strings.ReplaceAll above+ if _, err := conn.ExecContext(ctx, fmt.Sprintf(`SET search_path TO "%s", public;`, safeSchemaName)); err != nil { // NOSONAR(go:S2077) safeSchemaName is sanitized via strings.ReplaceAll abovereturn nil, err}}diff --git a/backend/plugin/db/pg/query_search_path_test.go b/backend/plugin/db/pg/query_search_path_test.gonew file mode 100644index 0000000000..141d0aee9f--- /dev/null+++ b/backend/plugin/db/pg/query_search_path_test.go@@ -0,0 +1,119 @@+package pg++import (+ "context"+ "testing"++ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/common/testcontainer"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/plugin/db"+)++func TestQueryConnSearchPathIncludesPublicAfterSelectedSchema(t *testing.T) {+ ctx := context.Background()++ pgContainer := testcontainer.GetTestPgContainer(ctx, t)+ defer pgContainer.Close(ctx)++ rawDB := pgContainer.GetDB()+ require.NoError(t, rawDB.Ping())+ _, err := rawDB.ExecContext(ctx, `+ CREATE SCHEMA app;+ CREATE TABLE public.lookup_precedence (marker text);+ CREATE TABLE app.lookup_precedence (marker text);+ INSERT INTO public.lookup_precedence VALUES ('public');+ INSERT INTO app.lookup_precedence VALUES ('app');+ CREATE FUNCTION public.polar_osfs_extract_table_name(rel text) RETURNS text+ LANGUAGE sql+ AS $$ SELECT rel $$;+ CREATE FUNCTION public.polar_alter_relation_to_oss_with_indexes(rel text) RETURNS text+ LANGUAGE plpgsql+ AS $$+ BEGIN+ RETURN polar_osfs_extract_table_name(rel);+ END;+ $$;+ `)+ require.NoError(t, err)++ driver, err := (&Driver{}).Open(ctx, storepb.Engine_POSTGRES, db.ConnectionConfig{+ DataSource: &storepb.DataSource{+ Host: pgContainer.GetHost(),+ Port: pgContainer.GetPort(),+ Username: "postgres",+ },+ Password: "root-password",+ ConnectionContext: db.ConnectionContext{DatabaseName: "postgres"},+ })+ require.NoError(t, err)+ defer driver.Close(ctx)++ conn, err := driver.GetDB().Conn(ctx)+ require.NoError(t, err)+ defer conn.Close()++ queryContext := db.QueryContext{+ Schema: "app",+ Limit: 5000,+ MaximumSQLResultSize: 1 << 30,+ }+ results, err := driver.QueryConn(ctx, conn, `SELECT public.polar_alter_relation_to_oss_with_indexes('content_messages_2025q1'::text);`, queryContext)+ require.NoError(t, err)+ require.Equal(t, "content_messages_2025q1", firstStringValue(t, results))++ results, err = driver.QueryConn(ctx, conn, `SELECT marker FROM lookup_precedence;`, queryContext)+ require.NoError(t, err)+ require.Equal(t, "app", firstStringValue(t, results))+}++func TestQueryConnSearchPathEscapesSelectedSchemaName(t *testing.T) {+ ctx := context.Background()++ pgContainer := testcontainer.GetTestPgContainer(ctx, t)+ defer pgContainer.Close(ctx)++ rawDB := pgContainer.GetDB()+ require.NoError(t, rawDB.Ping())+ _, err := rawDB.ExecContext(ctx, `+ CREATE SCHEMA "app""schema";+ CREATE TABLE "app""schema".lookup_precedence (marker text);+ INSERT INTO "app""schema".lookup_precedence VALUES ('quoted');+ `)+ require.NoError(t, err)++ driver, err := (&Driver{}).Open(ctx, storepb.Engine_POSTGRES, db.ConnectionConfig{+ DataSource: &storepb.DataSource{+ Host: pgContainer.GetHost(),+ Port: pgContainer.GetPort(),+ Username: "postgres",+ },+ Password: "root-password",+ ConnectionContext: db.ConnectionContext{DatabaseName: "postgres"},+ })+ require.NoError(t, err)+ defer driver.Close(ctx)++ conn, err := driver.GetDB().Conn(ctx)+ require.NoError(t, err)+ defer conn.Close()++ results, err := driver.QueryConn(ctx, conn, `SELECT marker FROM lookup_precedence;`, db.QueryContext{+ Schema: `app"schema`,+ Limit: 5000,+ MaximumSQLResultSize: 1 << 30,+ })+ require.NoError(t, err)+ require.Equal(t, "quoted", firstStringValue(t, results))+}++func firstStringValue(t *testing.T, results []*v1pb.QueryResult) string {+ t.Helper()+ require.NotEmpty(t, results)+ require.Empty(t, results[0].GetError())+ require.NotEmpty(t, results[0].GetRows())+ require.NotEmpty(t, results[0].GetRows()[0].GetValues())+ return results[0].GetRows()[0].GetValues()[0].GetStringValue()+}diff --git a/backend/plugin/parser/pg/access_tables.go b/backend/plugin/parser/pg/access_tables.goindex 3ce85f4f84..a4fe01f578 100644--- a/backend/plugin/parser/pg/access_tables.go+++ b/backend/plugin/parser/pg/access_tables.go@@ -15,6 +15,8 @@ type ExtractAccessTablesOption struct {DefaultDatabase string// DefaultSchema is the default schema name to use when table reference doesn't specify one.DefaultSchema string+ // SearchPath is the schema search path to use when table reference doesn't specify one.+ SearchPath []string// SkipMetadataValidation skips metadata lookup and validation.// When true, returns all table references found in SQL without checking if they exist.SkipMetadataValidation bool@@ -38,8 +40,11 @@ func ExtractAccessTables(statement string, option ExtractAccessTablesOption) ([]return nil, errors.Errorf("expected exactly 1 statement, got %d", len(omniStmts))}- searchPath := []string{option.DefaultSchema}- if option.DefaultSchema == "" {+ searchPath := option.SearchPath+ if len(searchPath) == 0 && option.DefaultSchema != "" {+ searchPath = []string{option.DefaultSchema}+ }+ if len(searchPath) == 0 {searchPath = []string{"public"}}diff --git a/backend/plugin/parser/pg/query_span.go b/backend/plugin/parser/pg/query_span.goindex 037397ad70..7fdb793aff 100644--- a/backend/plugin/parser/pg/query_span.go+++ b/backend/plugin/parser/pg/query_span.go@@ -25,7 +25,7 @@ func GetQuerySpan(ctx context.Context, gCtx base.GetQuerySpanContext, stmt base.}searchPath := meta.GetSearchPath()if schema != "" {- searchPath = []string{schema}+ searchPath = searchPathForSelectedSchema(schema, searchPath)}extractor := newOmniQuerySpanExtractor(database, searchPath, gCtx)diff --git a/backend/plugin/parser/pg/query_span_loader_integration_test.go b/backend/plugin/parser/pg/query_span_loader_integration_test.goindex 0d557ebad8..25457e7eac 100644--- a/backend/plugin/parser/pg/query_span_loader_integration_test.go+++ b/backend/plugin/parser/pg/query_span_loader_integration_test.go@@ -73,6 +73,86 @@ func TestLoaderIntegration_BYT9215_BadQuotedIdentifier(t *testing.T) {}}+func TestGetQuerySpanWithSelectedSchemaFallsBackToPublic(t *testing.T) {+ meta := &storepb.DatabaseSchemaMetadata{+ Name: "db",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "app",+ },+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{{+ Name: "customer",+ Columns: []*storepb.ColumnMetadata{+ {Name: "ssn", Type: "text"},+ },+ }},+ },+ },+ }+ getter, lister := buildMockDatabaseMetadataGetter([]*storepb.DatabaseSchemaMetadata{meta})+ span, err := GetQuerySpan(context.TODO(), base.GetQuerySpanContext{+ GetDatabaseMetadataFunc: getter,+ ListDatabaseNamesFunc: lister,+ }, base.Statement{Text: `SELECT ssn FROM customer`}, "db", "app", false)+ if err != nil {+ t.Fatalf("GetQuerySpan: %v", err)+ }+ if len(span.Results) != 1 {+ t.Fatalf("got %d results, want 1", len(span.Results))+ }+ want := base.ColumnResource{Database: "db", Schema: "public", Table: "customer", Column: "ssn"}+ if _, ok := span.Results[0].SourceColumns[want]; !ok {+ t.Fatalf("result %q missing public fallback source %+v; have %+v", span.Results[0].Name, want, span.Results[0].SourceColumns)+ }+ wantAccess := base.ColumnResource{Database: "db", Schema: "public", Table: "customer"}+ if _, ok := span.SourceColumns[wantAccess]; !ok {+ t.Fatalf("span missing public fallback access source %+v; have %+v", wantAccess, span.SourceColumns)+ }+}++func TestGetQuerySpanSelectedSchemaTakesPrecedenceOverPublic(t *testing.T) {+ meta := &storepb.DatabaseSchemaMetadata{+ Name: "db",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "app",+ Tables: []*storepb.TableMetadata{{+ Name: "customer",+ Columns: []*storepb.ColumnMetadata{+ {Name: "email", Type: "text"},+ },+ }},+ },+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{{+ Name: "customer",+ Columns: []*storepb.ColumnMetadata{+ {Name: "ssn", Type: "text"},+ },+ }},+ },+ },+ }+ getter, lister := buildMockDatabaseMetadataGetter([]*storepb.DatabaseSchemaMetadata{meta})+ span, err := GetQuerySpan(context.TODO(), base.GetQuerySpanContext{+ GetDatabaseMetadataFunc: getter,+ ListDatabaseNamesFunc: lister,+ }, base.Statement{Text: `SELECT email FROM customer`}, "db", "app", false)+ if err != nil {+ t.Fatalf("GetQuerySpan: %v", err)+ }+ if len(span.Results) != 1 {+ t.Fatalf("got %d results, want 1", len(span.Results))+ }+ want := base.ColumnResource{Database: "db", Schema: "app", Table: "customer", Column: "email"}+ if _, ok := span.Results[0].SourceColumns[want]; !ok {+ t.Fatalf("result %q missing selected-schema source %+v; have %+v", span.Results[0].Name, want, span.Results[0].SourceColumns)+ }+}+func TestLoaderIntegration_BrokenEnumCascade(t *testing.T) {// Real failure chain: table references a user-defined type that does// not exist in metadata. Real install of the table fails (omni cannotdiff --git a/backend/plugin/parser/pg/query_span_omni.go b/backend/plugin/parser/pg/query_span_omni.goindex 0807b2f17b..8c693a3a7a 100644--- a/backend/plugin/parser/pg/query_span_omni.go+++ b/backend/plugin/parser/pg/query_span_omni.go@@ -211,6 +211,7 @@ func (e *omniQuerySpanExtractor) getQuerySpan(ctx context.Context, stmt string)accessTables, err := ExtractAccessTables(stmt, ExtractAccessTablesOption{DefaultDatabase: e.defaultDatabase,DefaultSchema: e.searchPath[0],+ SearchPath: e.searchPath,GetDatabaseMetadata: e.gCtx.GetDatabaseMetadataFunc,Ctx: ctx,InstanceID: e.gCtx.InstanceID,@@ -1049,11 +1050,17 @@ func (e *omniQuerySpanExtractor) extractColumnsFromRangeVar(rv *ast.RangeVar) []}}- schema := rv.Schemaname- if schema == "" && len(e.searchPath) > 0 {- schema = e.searchPath[0]+ var rel *catalog.Relation+ if rv.Schemaname != "" {+ rel = e.cat.GetRelation(rv.Schemaname, rv.Relname)+ } else {+ for _, schema := range e.searchPath {+ rel = e.cat.GetRelation(schema, rv.Relname)+ if rel != nil {+ break+ }+ }}- rel := e.cat.GetRelation(schema, rv.Relname)if rel == nil {return nil}diff --git a/backend/plugin/parser/pg/query_span_omni_plpgsql.go b/backend/plugin/parser/pg/query_span_omni_plpgsql.goindex 79509cb6b7..b56613212a 100644--- a/backend/plugin/parser/pg/query_span_omni_plpgsql.go+++ b/backend/plugin/parser/pg/query_span_omni_plpgsql.go@@ -669,6 +669,7 @@ func (a *plpgsqlAnalyzer) collectAccessTablesFromSQL(sql string) {accessTables, err := ExtractAccessTables(sql, ExtractAccessTablesOption{DefaultDatabase: a.extractor.defaultDatabase,DefaultSchema: a.extractor.searchPath[0],+ SearchPath: a.extractor.searchPath,GetDatabaseMetadata: a.extractor.gCtx.GetDatabaseMetadataFunc,Ctx: a.extractor.ctx,InstanceID: a.extractor.gCtx.InstanceID,diff --git a/backend/plugin/parser/pg/resource_change.go b/backend/plugin/parser/pg/resource_change.goindex 899ccb04a7..ba5c699c1e 100644--- a/backend/plugin/parser/pg/resource_change.go+++ b/backend/plugin/parser/pg/resource_change.go@@ -21,7 +21,7 @@ func extractChangedResources(database string, currentSchema string, dbMetadata *changedResources := model.NewChangedResources(dbMetadata)searchPath := dbMetadata.GetSearchPath()if currentSchema != "" {- searchPath = []string{currentSchema}+ searchPath = searchPathForSelectedSchema(currentSchema, searchPath)}if len(searchPath) == 0 {searchPath = []string{"public"}@@ -66,7 +66,7 @@ func extractChangedResources(database string, currentSchema string, dbMetadata *case *ast.CreateStmt:if n.Relation != nil {- db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)+ db, schema, table := extractNewRangeVarNames(n.Relation, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)}@@ -85,25 +85,13 @@ func extractChangedResources(database string, currentSchema string, dbMetadata *continue}if n.Relation != nil {- db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)- if schema == "" {- schemaName, _ := dbMetadata.SearchObject(searchPath, table)- if schemaName != "" {- schema = schemaName- }- }+ db, schema, table := extractExistingRangeVarNames(n.Relation, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, true)}case *ast.RenameStmt:if n.Relation != nil {- db, schema, oldTableName := extractRangeVarNames(n.Relation, database, searchPath)- if schema == "" {- schemaName, _ := dbMetadata.SearchObject(searchPath, oldTableName)- if schemaName != "" {- schema = schemaName- }- }+ db, schema, oldTableName := extractExistingRangeVarNames(n.Relation, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: oldTableName}, true)if n.Newname != "" {changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: n.Newname}, false)@@ -112,25 +100,13 @@ func extractChangedResources(database string, currentSchema string, dbMetadata *case *ast.IndexStmt:if n.Relation != nil {- db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)- if schema == "" {- schemaName, _ := dbMetadata.SearchObject(searchPath, table)- if schemaName != "" {- schema = schemaName- }- }+ db, schema, table := extractExistingRangeVarNames(n.Relation, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)}case *ast.InsertStmt:if n.Relation != nil {- db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)- if schema == "" {- schemaName, _ := dbMetadata.SearchObject(searchPath, table)- if schemaName != "" {- schema = schemaName- }- }+ db, schema, table := extractExistingRangeVarNames(n.Relation, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)}// Count insert rows from VALUES@@ -140,13 +116,7 @@ func extractChangedResources(database string, currentSchema string, dbMetadata *case *ast.UpdateStmt:if n.Relation != nil {- db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)- if schema == "" {- schemaName, _ := dbMetadata.SearchObject(searchPath, table)- if schemaName != "" {- schema = schemaName- }- }+ db, schema, table := extractExistingRangeVarNames(n.Relation, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)}dmlCount++@@ -156,13 +126,7 @@ func extractChangedResources(database string, currentSchema string, dbMetadata *case *ast.DeleteStmt:if n.Relation != nil {- db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)- if schema == "" {- schemaName, _ := dbMetadata.SearchObject(searchPath, table)- if schemaName != "" {- schema = schemaName- }- }+ db, schema, table := extractExistingRangeVarNames(n.Relation, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)}dmlCount++@@ -176,20 +140,20 @@ func extractChangedResources(database string, currentSchema string, dbMetadata *if !ok {continue}- db, schema, table := extractRangeVarNames(rv, database, searchPath)+ db, schema, table := extractExistingRangeVarNames(rv, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, true)}}case *ast.MergeStmt:if n.Relation != nil {- db, schema, table := extractRangeVarNames(n.Relation, database, searchPath)+ db, schema, table := extractExistingRangeVarNames(n.Relation, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)}case *ast.CreateTableAsStmt:if n.Into != nil && n.Into.Rel != nil {- db, schema, table := extractRangeVarNames(n.Into.Rel, database, searchPath)+ db, schema, table := extractNewRangeVarNames(n.Into.Rel, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)}@@ -197,7 +161,7 @@ func extractChangedResources(database string, currentSchema string, dbMetadata *// SELECT ... INTO target_table is a write (classified DDL via the INTO clause,// which may sit on the first arm of a set operation).if into := omniIntoClause(n); into != nil && into.Rel != nil {- db, schema, table := extractRangeVarNames(into.Rel, database, searchPath)+ db, schema, table := extractNewRangeVarNames(into.Rel, database, searchPath, dbMetadata)changedResources.AddTable(db, schema, &storepb.ChangedResourceTable{Name: table}, false)}@@ -227,6 +191,45 @@ func extractRangeVarNames(rv *ast.RangeVar, defaultDB string, searchPath []strinreturn db, schema, table}+func extractExistingRangeVarNames(rv *ast.RangeVar, defaultDB string, searchPath []string, dbMetadata *model.DatabaseMetadata) (string, string, string) {+ db := rv.Catalogname+ schema := rv.Schemaname+ table := rv.Relname+ if db == "" {+ db = defaultDB+ }+ if schema == "" {+ schemaName := searchRelationObject(dbMetadata, searchPath, table)+ if schemaName != "" {+ schema = schemaName+ } else if len(searchPath) > 0 {+ schema = searchPath[0]+ }+ }+ return db, schema, table+}++func extractNewRangeVarNames(rv *ast.RangeVar, defaultDB string, searchPath []string, dbMetadata *model.DatabaseMetadata) (string, string, string) {+ db, schema, table := extractRangeVarNames(rv, defaultDB, searchPath)+ if rv.Schemaname == "" && len(searchPath) > 1 && dbMetadata.GetSchemaMetadata(schema) == nil {+ schema = ""+ }+ return db, schema, table+}++func searchRelationObject(dbMetadata *model.DatabaseMetadata, searchPath []string, name string) string {+ for _, schemaName := range searchPath {+ schema := dbMetadata.GetSchemaMetadata(schemaName)+ if schema == nil {+ continue+ }+ if schema.GetTable(name) != nil || schema.GetView(name) != nil || schema.GetMaterializedView(name) != nil || schema.GetExternalTable(name) != nil {+ return schema.GetProto().GetName()+ }+ }+ return ""+}+// handleDropTableOmni handles DROP TABLE/MATERIALIZED VIEW.func handleDropTableOmni(n *ast.DropStmt, database string, searchPath []string, dbMetadata *model.DatabaseMetadata, changedResources *model.ChangedResources) {if n.Objects == nil {@@ -239,7 +242,7 @@ func handleDropTableOmni(n *ast.DropStmt, database string, searchPath []string,}db, schema, name := extractNameListParts(nameList, database)if schema == "" {- schemaName, _ := dbMetadata.SearchObject(searchPath, name)+ schemaName := searchRelationObject(dbMetadata, searchPath, name)if schemaName == "" {if len(searchPath) > 0 {schema = searchPath[0]diff --git a/backend/plugin/parser/pg/resource_change_test.go b/backend/plugin/parser/pg/resource_change_test.goindex 967bcb43f1..df9b1bdeec 100644--- a/backend/plugin/parser/pg/resource_change_test.go+++ b/backend/plugin/parser/pg/resource_change_test.go@@ -62,6 +62,71 @@ func TestExtractChangedResources(t *testing.T) {require.Equal(t, want, got)}+func TestExtractChangedResourcesSelectedSchemaFallsBackToPublicForExistingTarget(t *testing.T) {+ const statement = `INSERT INTO customer VALUES (1);`++ for _, tc := range []struct {+ name string+ appTables []*storepb.TableMetadata+ appFuncs []*storepb.FunctionMetadata+ wantSchema string+ }{+ {+ name: "falls back to public when selected schema lacks the table",+ wantSchema: "public",+ },+ {+ name: "selected schema still takes precedence",+ appTables: []*storepb.TableMetadata{{+ Name: "customer",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "int"},+ },+ }},+ wantSchema: "app",+ },+ {+ name: "relation lookup skips function in selected schema",+ appFuncs: []*storepb.FunctionMetadata{{+ Name: "customer",+ }},+ wantSchema: "public",+ },+ } {+ t.Run(tc.name, func(t *testing.T) {+ dbMetadata := model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{+ Name: "db",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "app",+ Tables: tc.appTables,+ Functions: tc.appFuncs,+ },+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{{+ Name: "customer",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "int"},+ },+ }},+ },+ },+ }, []byte{}, &storepb.DatabaseConfig{}, storepb.Engine_POSTGRES, true /* caseSensitive */)++ want := model.NewChangedResources(dbMetadata)+ want.AddTable("db", tc.wantSchema, &storepb.ChangedResourceTable{Name: "customer"}, false)++ stmts, err := base.ParseStatements(storepb.Engine_POSTGRES, statement)+ require.NoError(t, err)+ asts := base.ExtractASTs(stmts)+ got, err := extractChangedResources("db", "app", dbMetadata, asts, statement)+ require.NoError(t, err)+ require.Equal(t, want, got.ChangedResources)+ })+ }+}+func TestExtractChangedResourcesTruncate(t *testing.T) {dbMetadata := model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{}, []byte{}, &storepb.DatabaseConfig{}, storepb.Engine_POSTGRES, true /* caseSensitive */)const statement = `TRUNCATE TABLE public.t1, myschema.t2;`diff --git a/backend/plugin/parser/pg/search_path.go b/backend/plugin/parser/pg/search_path.gonew file mode 100644index 0000000000..36744bc574--- /dev/null+++ b/backend/plugin/parser/pg/search_path.go@@ -0,0 +1,13 @@+package pg++import "strings"++func searchPathForSelectedSchema(selectedSchema string, defaultSearchPath []string) []string {+ if selectedSchema == "" {+ return defaultSearchPath+ }+ if selectedSchema == "public" || strings.ContainsRune(selectedSchema, '\x00') {+ return []string{selectedSchema}+ }+ return []string{selectedSchema, "public"}+}diff --git a/backend/tests/sql_dml_table_scope_test.go b/backend/tests/sql_dml_table_scope_test.goindex 8701e8b236..ade6c4c293 100644--- a/backend/tests/sql_dml_table_scope_test.go+++ b/backend/tests/sql_dml_table_scope_test.go@@ -644,15 +644,13 @@ func TestSQLEditorTableScopedDMLEdgeCases(t *testing.T) {})// 9. Codex P1 search_path-override bypass guard (SUP-222 / BYT-9698). Postgres- // honors QueryRequest.schema by running `SET search_path TO "<schema>"` before- // execution, so an UNQUALIFIED `INSERT INTO t_sbx` writes to <request_schema>.t_sbx.- // The grant is table-scoped to public.t_sbx. The user sends Schema="other_schema"- // + an unqualified INSERT: Postgres would write other_schema.t_sbx (NOT granted).- // The fix resolves the write target against the request schema (other_schema), so- // the public-scoped grant doesn't cover it → DENIED on other_schema/tables/t_sbx.- // Before the fix, resolution ignored the request schema and used public, wrongly- // ALLOWING the write to other_schema.t_sbx — the fail-open authorization bypass.- // The target schema/table need not exist: authorization precedes execution.+ // honors QueryRequest.schema by running `SET search_path TO "<schema>", public`+ // before execution, so an UNQUALIFIED `INSERT INTO t_sbx` writes to+ // <request_schema>.t_sbx when that relation exists. The grant is table-scoped to+ // public.t_sbx. The user sends Schema="other_schema" + an unqualified INSERT:+ // Postgres writes other_schema.t_sbx (NOT granted). The write-target extractor+ // must keep selected-schema precedence, so the public-scoped grant does not cover+ // it → DENIED on other_schema/tables/t_sbx.t.Run("RequestSchemaOverrideNotBypassed", func(t *testing.T) {ra := require.New(t)email, token := newLimitedUser(t)@@ -663,16 +661,22 @@ func TestSQLEditorTableScopedDMLEdgeCases(t *testing.T) {)setProjectBindings(t, readBinding(email), scopedBinding("roles/repro-write", email, cond))- // Ensure public.t_sbx exists (the granted target) via the change-database flow.+ // Ensure both possible targets exist via the change-database flow. With the SQL+ // Editor public fallback, PostgreSQL only routes the unqualified INSERT to+ // other_schema.t_sbx if the selected-schema relation exists.setupSheetResp, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{Parent: ctl.project.Name,- Sheet: &v1pb.Sheet{Content: []byte(`CREATE TABLE IF NOT EXISTS public.t_sbx (id int);`)},+ Sheet: &v1pb.Sheet{Content: []byte(`+ CREATE SCHEMA IF NOT EXISTS other_schema;+ CREATE TABLE IF NOT EXISTS public.t_sbx (id int);+ CREATE TABLE IF NOT EXISTS other_schema.t_sbx (id int);+ `)},}))ra.NoError(err)ra.NoError(ctl.changeDatabase(ctx, ctl.project, database, setupSheetResp.Msg, false))- // Unqualified INSERT + Schema="other_schema": Postgres SET search_path would route- // the write to other_schema.t_sbx, which the public-scoped grant does not cover.+ // Unqualified INSERT + Schema="other_schema": Postgres SET search_path routes the+ // write to other_schema.t_sbx, which the public-scoped grant does not cover.ctl.authInterceptor.token = tokenresp, qErr := ctl.sqlServiceClient.Query(ctx, connect.NewRequest(&v1pb.QueryRequest{Name: database.Name,@@ -692,7 +696,7 @@ func TestSQLEditorTableScopedDMLEdgeCases(t *testing.T) {ra.NotContains(strings.Join(last.GetPermissionDenied().GetResources(), ","),"schemas/public/tables/t_sbx",- "the request schema (other_schema), not public, must be the resolved write target",+ "the selected schema (other_schema), not public, must be the resolved write target",)})