Skip to content

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

fix(pg): include SET search_path in DML dry-run pre-executions (#19542)

p0ny6f707e53602d
diff --git a/backend/plugin/advisor/pg/advisor_insert_row_limit.go b/backend/plugin/advisor/pg/advisor_insert_row_limit.go
index c830f03f23..67f6167ed9 100644
--- a/backend/plugin/advisor/pg/advisor_insert_row_limit.go
+++ b/backend/plugin/advisor/pg/advisor_insert_row_limit.go
@@ -8,9 +8,8 @@ import (
"strconv"
"github.com/antlr4-go/antlr/v4"
- "github.com/pkg/errors"
-
parser "github.com/bytebase/parser/postgresql"
+ "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -47,7 +46,7 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Contex
}
var adviceList []*storepb.Advice
- var setRoles []string
+ var preExecutions []string
for _, stmtInfo := range checkCtx.ParsedStatements {
if stmtInfo.AST == nil {
continue
@@ -61,19 +60,19 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Contex
level: level,
title: checkCtx.Rule.Type.String(),
},
- maxRow: int(numberPayload.Number),
- driver: checkCtx.Driver,
- ctx: ctx,
- tokens: antlrAST.Tokens,
- setRoles: setRoles,
- TenantMode: checkCtx.TenantMode,
+ maxRow: int(numberPayload.Number),
+ driver: checkCtx.Driver,
+ ctx: ctx,
+ tokens: antlrAST.Tokens,
+ preExecutions: preExecutions,
+ TenantMode: checkCtx.TenantMode,
}
rule.SetBaseLine(stmtInfo.BaseLine())
checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)
adviceList = append(adviceList, checker.GetAdviceList()...)
- setRoles = rule.setRoles
+ preExecutions = rule.preExecutions
}
return adviceList, nil
@@ -82,13 +81,13 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Contex
type insertRowLimitRule struct {
BaseRule
- maxRow int
- driver *sql.DB
- ctx context.Context
- tokens *antlr.CommonTokenStream
- explainCount int
- setRoles []string
- TenantMode bool
+ maxRow int
+ driver *sql.DB
+ ctx context.Context
+ tokens *antlr.CommonTokenStream
+ explainCount int
+ preExecutions []string
+ TenantMode bool
}
func (*insertRowLimitRule) Name() string {
@@ -120,14 +119,7 @@ func (r *insertRowLimitRule) handleVariablesetstmt(ctx *parser.VariablesetstmtCo
return
}
- // Track SET ROLE statements
- if ctx.Set_rest() != nil && ctx.Set_rest().Set_rest_more() != nil {
- setRestMore := ctx.Set_rest().Set_rest_more()
- // Check if this is SET ROLE
- if setRestMore.ROLE() != nil {
- r.setRoles = append(r.setRoles, ctx.GetText())
- }
- }
+ r.preExecutions = appendSessionPreExecutionStatements(r.preExecutions, r.tokens, ctx)
}
func (r *insertRowLimitRule) handleInsertstmt(ctx *parser.InsertstmtContext) {
@@ -158,7 +150,7 @@ func (r *insertRowLimitRule) handleInsertstmt(ctx *parser.InsertstmtContext) {
res, err := advisor.Query(r.ctx, advisor.QueryContext{
TenantMode: r.TenantMode,
- PreExecutions: r.setRoles,
+ PreExecutions: r.preExecutions,
}, r.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", statementText))
if err != nil {
diff --git a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go
index e39a8a9b09..a7aca38260 100644
--- a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go
+++ b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go
@@ -5,11 +5,9 @@ import (
"database/sql"
"fmt"
- "github.com/pkg/errors"
-
"github.com/antlr4-go/antlr/v4"
-
parser "github.com/bytebase/parser/postgresql"
+ "github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
@@ -47,7 +45,7 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx adv
}
var adviceList []*storepb.Advice
- var setRoles []string
+ var preExecutions []string
for _, stmtInfo := range checkCtx.ParsedStatements {
if stmtInfo.AST == nil {
continue
@@ -61,19 +59,19 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx adv
level: level,
title: checkCtx.Rule.Type.String(),
},
- maxRow: int(numberPayload.Number),
- ctx: ctx,
- driver: checkCtx.Driver,
- tenantMode: checkCtx.TenantMode,
- setRoles: setRoles,
- tokens: antlrAST.Tokens,
+ maxRow: int(numberPayload.Number),
+ ctx: ctx,
+ driver: checkCtx.Driver,
+ tenantMode: checkCtx.TenantMode,
+ preExecutions: preExecutions,
+ tokens: antlrAST.Tokens,
}
rule.SetBaseLine(stmtInfo.BaseLine())
checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)
adviceList = append(adviceList, checker.GetAdviceList()...)
- setRoles = rule.setRoles
+ preExecutions = rule.preExecutions
}
return adviceList, nil
@@ -81,13 +79,13 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx adv
type statementAffectedRowLimitRule struct {
BaseRule
- maxRow int
- driver *sql.DB
- ctx context.Context
- explainCount int
- setRoles []string
- tenantMode bool
- tokens *antlr.CommonTokenStream
+ maxRow int
+ driver *sql.DB
+ ctx context.Context
+ explainCount int
+ preExecutions []string
+ tenantMode bool
+ tokens *antlr.CommonTokenStream
}
func (*statementAffectedRowLimitRule) Name() string {
@@ -123,14 +121,7 @@ func (r *statementAffectedRowLimitRule) handleVariablesetstmt(ctx *parser.Variab
return
}
- // Check if this is SET ROLE
- if ctx.SET() != nil && ctx.Set_rest() != nil && ctx.Set_rest().Set_rest_more() != nil {
- setRestMore := ctx.Set_rest().Set_rest_more()
- if setRestMore.ROLE() != nil {
- // Store the SET ROLE statement text
- r.setRoles = append(r.setRoles, getTextFromTokens(r.tokens, ctx))
- }
- }
+ r.preExecutions = appendSessionPreExecutionStatements(r.preExecutions, r.tokens, ctx)
}
func (r *statementAffectedRowLimitRule) handleUpdatestmt(ctx *parser.UpdatestmtContext) {
@@ -163,7 +154,7 @@ func (r *statementAffectedRowLimitRule) checkAffectedRows(ctx antlr.ParserRuleCo
// Run EXPLAIN to get estimated row count
res, err := advisor.Query(r.ctx, advisor.QueryContext{
TenantMode: r.tenantMode,
- PreExecutions: r.setRoles,
+ PreExecutions: r.preExecutions,
}, r.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", statementText))
if err != nil {
diff --git a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go
index d305ef8a36..d8baa43d49 100644
--- a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go
+++ b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go
@@ -46,7 +46,7 @@ func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Co
}
var adviceList []*storepb.Advice
- var setRoles []string
+ var preExecutions []string
for _, stmtInfo := range checkCtx.ParsedStatements {
if stmtInfo.AST == nil {
continue
@@ -60,18 +60,18 @@ func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Co
level: level,
title: checkCtx.Rule.Type.String(),
},
- ctx: ctx,
- driver: checkCtx.Driver,
- tenantMode: checkCtx.TenantMode,
- setRoles: setRoles,
- tokens: antlrAST.Tokens,
+ ctx: ctx,
+ driver: checkCtx.Driver,
+ tenantMode: checkCtx.TenantMode,
+ preExecutions: preExecutions,
+ tokens: antlrAST.Tokens,
}
rule.SetBaseLine(stmtInfo.BaseLine())
checker := NewGenericChecker([]Rule{rule})
antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)
adviceList = append(adviceList, checker.GetAdviceList()...)
- setRoles = rule.setRoles
+ preExecutions = rule.preExecutions
}
return adviceList, nil
@@ -79,12 +79,12 @@ func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Co
type statementDMLDryRunRule struct {
BaseRule
- driver *sql.DB
- ctx context.Context
- explainCount int
- setRoles []string
- tenantMode bool
- tokens *antlr.CommonTokenStream
+ driver *sql.DB
+ ctx context.Context
+ explainCount int
+ preExecutions []string
+ tenantMode bool
+ tokens *antlr.CommonTokenStream
}
// Name returns the rule name.
@@ -119,14 +119,7 @@ func (r *statementDMLDryRunRule) handleVariablesetstmt(ctx *parser.Variablesetst
return
}
- // Check if this is SET ROLE
- if ctx.SET() != nil && ctx.Set_rest() != nil && ctx.Set_rest().Set_rest_more() != nil {
- setRestMore := ctx.Set_rest().Set_rest_more()
- if setRestMore.ROLE() != nil {
- // Store the SET ROLE statement text
- r.setRoles = append(r.setRoles, getTextFromTokens(r.tokens, ctx))
- }
- }
+ r.preExecutions = appendSessionPreExecutionStatements(r.preExecutions, r.tokens, ctx)
}
func (r *statementDMLDryRunRule) handleInsertstmt(ctx *parser.InsertstmtContext) {
@@ -166,7 +159,7 @@ func (r *statementDMLDryRunRule) checkDMLDryRun(ctx antlr.ParserRuleContext) {
// Run EXPLAIN to perform dry run
_, err := advisor.Query(r.ctx, advisor.QueryContext{
TenantMode: r.tenantMode,
- PreExecutions: r.setRoles,
+ PreExecutions: r.preExecutions,
}, r.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", statementText))
if err != nil {
diff --git a/backend/plugin/advisor/pg/utils.go b/backend/plugin/advisor/pg/utils.go
index 5d27f57639..31d9b43978 100644
--- a/backend/plugin/advisor/pg/utils.go
+++ b/backend/plugin/advisor/pg/utils.go
@@ -12,6 +12,52 @@ import (
"github.com/bytebase/bytebase/backend/plugin/parser/pg"
)
+// appendSessionPreExecutionStatements tracks top-level SET statements that affect
+// how subsequent DML statements should be planned/executed in the same script.
+func appendSessionPreExecutionStatements(preExecutions []string, tokens *antlr.CommonTokenStream, ctx *parser.VariablesetstmtContext) []string {
+ if ctx == nil {
+ return preExecutions
+ }
+
+ if !isRoleOrSearchPathSetStatement(ctx) {
+ return preExecutions
+ }
+
+ return append(preExecutions, getTextFromTokens(tokens, ctx))
+}
+
+func isRoleOrSearchPathSetStatement(ctx *parser.VariablesetstmtContext) bool {
+ if ctx == nil {
+ return false
+ }
+
+ setRest := ctx.Set_rest()
+ if setRest == nil {
+ return false
+ }
+ setRestMore := setRest.Set_rest_more()
+ if setRestMore == nil {
+ return false
+ }
+
+ // Covers SET ROLE / SET SESSION ROLE syntax.
+ if setRestMore.ROLE() != nil {
+ return true
+ }
+
+ genericSet := setRestMore.Generic_set()
+ if genericSet == nil {
+ return false
+ }
+ varName := genericSet.Var_name()
+ if varName == nil || len(varName.AllColid()) != 1 {
+ return false
+ }
+
+ name := pg.NormalizePostgreSQLColid(varName.Colid(0))
+ return strings.EqualFold(name, "role") || strings.EqualFold(name, "search_path")
+}
+
// isTopLevel checks if the context is at the top level of the parse tree.
// Top level contexts are: RootContext, StmtblockContext, StmtmultiContext, or StmtContext.
func isTopLevel(ctx antlr.Tree) bool {
diff --git a/backend/plugin/advisor/pg/utils_test.go b/backend/plugin/advisor/pg/utils_test.go
new file mode 100644
index 0000000000..8581044f42
--- /dev/null
+++ b/backend/plugin/advisor/pg/utils_test.go
@@ -0,0 +1,74 @@
+package pg
+
+import (
+ "testing"
+
+ "github.com/antlr4-go/antlr/v4"
+ pgparser "github.com/bytebase/parser/postgresql"
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+type sessionPreExecutionCollector struct {
+ *pgparser.BasePostgreSQLParserListener
+ tokens *antlr.CommonTokenStream
+ preExecutions []string
+}
+
+func (l *sessionPreExecutionCollector) EnterVariablesetstmt(ctx *pgparser.VariablesetstmtContext) {
+ l.preExecutions = appendSessionPreExecutionStatements(l.preExecutions, l.tokens, ctx)
+}
+
+func TestAppendSessionPreExecutionStatements(t *testing.T) {
+ tests := []struct {
+ name string
+ sql string
+ want []string
+ }{
+ {
+ name: "set role keyword syntax",
+ sql: "SET ROLE admin; INSERT INTO t VALUES (1);",
+ want: []string{"SET ROLE admin"},
+ },
+ {
+ name: "set role generic syntax",
+ sql: "SET role = 'admin'; INSERT INTO t VALUES (1);",
+ want: []string{"SET role = 'admin'"},
+ },
+ {
+ name: "set search path",
+ sql: "SET search_path = myschema, public; UPDATE t SET a = 1;",
+ want: []string{"SET search_path = myschema, public"},
+ },
+ {
+ name: "ignore unrelated set variable",
+ sql: "SET statement_timeout = '1s'; DELETE FROM t;",
+ want: nil,
+ },
+ }
+
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ statements, err := base.ParseStatements(storepb.Engine_POSTGRES, tc.sql)
+ require.NoError(t, err)
+
+ var preExecutions []string
+ for _, stmt := range statements {
+ if stmt.AST == nil {
+ continue
+ }
+
+ antlrAST, ok := base.GetANTLRAST(stmt.AST)
+ require.True(t, ok)
+
+ collector := &sessionPreExecutionCollector{tokens: antlrAST.Tokens}
+ antlr.ParseTreeWalkerDefault.Walk(collector, antlrAST.Tree)
+ preExecutions = append(preExecutions, collector.preExecutions...)
+ }
+
+ require.Equal(t, tc.want, preExecutions)
+ })
+ }
+}