Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix: add public to search path (#20770)

ecmadao2f9eda842054
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.go
index 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.go
index 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.go
index 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 above
return nil, err
}
}
diff --git a/backend/plugin/db/pg/query_search_path_test.go b/backend/plugin/db/pg/query_search_path_test.go
new file mode 100644
index 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.go
index 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.go
index 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.go
index 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 cannot
diff --git a/backend/plugin/parser/pg/query_span_omni.go b/backend/plugin/parser/pg/query_span_omni.go
index 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.go
index 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.go
index 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 []strin
return 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.go
index 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.go
new file mode 100644
index 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.go
index 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 = token
resp, 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",
)
})