Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
package tidb
import (
"strings"
"unicode"
omniast "github.com/bytebase/omni/tidb/ast"
tidbast "github.com/pingcap/tidb/pkg/parser/ast"
"github.com/pkg/errors"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/store/model"
"github.com/bytebase/bytebase/backend/utils"
)
func init() {
base.RegisterExtractChangedResourcesFunc(storepb.Engine_TIDB, extractChangedResources)
}
func extractChangedResources(database string, _ string, dbMetadata *model.DatabaseMetadata, asts []base.AST, statement string) (*base.ChangeSummary, error) {
summary := &base.ChangeSummary{
ChangedResources: model.NewChangedResources(dbMetadata),
}
for _, ast := range asts {
tidbAST, ok := GetTiDBAST(ast)
if !ok {
// The pingcap re-parse rejects some statements omni accepts. Read those from the
// omni AST rather than failing the summary of every other statement.
omniAST, ok := ast.(*OmniAST)
if !ok {
return nil, errors.New("expected TiDB AST")
}
addOmniTables(database, omniAST.Node, summary.ChangedResources)
countOmniDML(summary, omniAST)
continue
}
node := tidbAST.Node
err := getResourceChanges(database, node, statement, summary.ChangedResources)
if err != nil {
return nil, err
}
switch n := node.(type) {
case *tidbast.InsertStmt:
if len(n.Lists) > 0 {
summary.InsertCount += len(n.Lists)
continue
}
addSampleDML(summary, n.Text())
case *tidbast.UpdateStmt, *tidbast.DeleteStmt:
addSampleDML(summary, node.Text())
case *tidbast.NonTransactionalDMLStmt:
if n.DryRun == tidbast.NoDryRun {
addBatchSampleDML(summary, ast)
}
default:
}
}
return summary, nil
}
// addOmniTables records the tables an omni INSERT, UPDATE, DELETE, or BATCH statement names, as
// getResourceChanges does for the pingcap AST.
func addOmniTables(database string, node omniast.Node, changedResources *model.ChangedResources) {
var tableExprs []omniast.TableExpr
switch n := node.(type) {
case *omniast.InsertStmt:
if n.Table != nil {
tableExprs = append(tableExprs, n.Table)
}
case *omniast.UpdateStmt:
tableExprs = n.Tables
case *omniast.DeleteStmt:
tableExprs = append(append(tableExprs, n.Tables...), n.Using...)
case *omniast.BatchStmt:
if n.DryRun == omniast.BatchDryRunNone {
addOmniTables(database, n.DML, changedResources)
}
return
default:
return
}
var add func(expr omniast.TableExpr)
add = func(expr omniast.TableExpr) {
switch e := expr.(type) {
case *omniast.TableRef:
d := e.Schema
if d == "" {
d = database
}
changedResources.AddTable(d, "", &storepb.ChangedResourceTable{Name: e.Name}, false)
case *omniast.JoinClause:
add(e.Left)
add(e.Right)
default:
}
}
for _, expr := range tableExprs {
add(expr)
}
}
func countOmniDML(summary *base.ChangeSummary, omniAST *OmniAST) {
switch n := omniAST.Node.(type) {
case *omniast.InsertStmt:
switch {
case len(n.Values) > 0:
summary.InsertCount += len(n.Values)
case len(n.SetList) > 0:
summary.InsertCount++
default:
addSampleDML(summary, omniAST.Text)
}
case *omniast.UpdateStmt, *omniast.DeleteStmt:
addSampleDML(summary, omniAST.Text)
case *omniast.BatchStmt:
if n.DryRun == omniast.BatchDryRunNone {
addBatchSampleDML(summary, omniAST)
}
default:
}
}
// addBatchSampleDML samples the DML inside a BATCH statement, because EXPLAIN rejects the
// BATCH syntax. A BATCH without an omni AST is counted but not sampled.
func addBatchSampleDML(summary *base.ChangeSummary, ast base.AST) {
omniAST, ok := ast.(*OmniAST)
if !ok {
summary.DMLCount++
return
}
batch, ok := omniAST.Node.(*omniast.BatchStmt)
if !ok {
summary.DMLCount++
return
}
// The parser reads the body of an executable comment, so the DML's location can fall inside one
// and the slice would leave the comment unclosed.
if strings.Contains(omniAST.Text, "/*!") || strings.Contains(omniAST.Text, "/*T!") || strings.Contains(omniAST.Text, "/*M!") {
summary.DMLCount++
return
}
var loc omniast.Loc
switch dml := batch.DML.(type) {
case *omniast.DeleteStmt:
loc = dml.Loc
case *omniast.UpdateStmt:
loc = dml.Loc
case *omniast.InsertStmt:
loc = dml.Loc
default:
summary.DMLCount++
return
}
end := loc.End
if end <= loc.Start || end > len(omniAST.Text) {
end = len(omniAST.Text)
}
if loc.Start <= 0 || loc.Start >= end {
summary.DMLCount++
return
}
addSampleDML(summary, omniAST.Text[loc.Start:end])
}
func addSampleDML(summary *base.ChangeSummary, text string) {
summary.DMLCount++
summary.DMLStatements = append(summary.DMLStatements, trimStatement(text))
}
// addTiDBObjectDatabase records a database-only write target for a non-table object DDL
// (view/sequence) ONLY when its name carries an explicit database qualifier. An unqualified
// name records nothing (request-database fallback). SUP-222 / BYT-9698.
func addTiDBObjectDatabase(changedResources *model.ChangedResources, name *tidbast.TableName) {
if name != nil && name.Schema.O != "" {
changedResources.AddDatabase(name.Schema.O)
}
}
func getResourceChanges(database string, node tidbast.StmtNode, _ string, changedResources *model.ChangedResources) error {
switch node := node.(type) {
case *tidbast.CreateTableStmt:
d, table := node.Table.Schema.O, node.Table.Name.O
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table,
},
false,
)
case *tidbast.DropTableStmt:
if node.IsView {
// Views aren't tracked as changed tables (risk/approval doesn't use them), but a
// qualified cross-database DROP VIEW is gated by its target database. SUP-222.
for _, name := range node.Tables {
addTiDBObjectDatabase(changedResources, name)
}
return nil
}
for _, name := range node.Tables {
d, table := name.Schema.O, name.Name.O
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table,
},
true,
)
}
case *tidbast.AlterTableStmt:
d, table := node.Table.Schema.O, node.Table.Name.O
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table,
},
true,
)
case *tidbast.TruncateTableStmt:
d, table := node.Table.Schema.O, node.Table.Name.O
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table,
},
true,
)
case *tidbast.LoadDataStmt:
if node.Table != nil {
d, table := node.Table.Schema.O, node.Table.Name.O
if d == "" {
d = database
}
changedResources.AddTable(d, "", &storepb.ChangedResourceTable{Name: table}, false)
}
case *tidbast.ImportIntoStmt:
if node.Table != nil {
d, table := node.Table.Schema.O, node.Table.Name.O
if d == "" {
d = database
}
changedResources.AddTable(d, "", &storepb.ChangedResourceTable{Name: table}, false)
}
case *tidbast.RenameTableStmt:
for _, tableToTable := range node.TableToTables {
{
d, table := tableToTable.OldTable.Schema.O, tableToTable.OldTable.Name.O
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table,
},
false,
)
}
{
d, table := tableToTable.NewTable.Schema.O, tableToTable.NewTable.Name.O
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table,
},
false,
)
}
}
case *tidbast.CreateIndexStmt:
d, table := node.Table.Schema.O, node.Table.Name.O
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table,
},
false,
)
case *tidbast.DropIndexStmt:
d, table := node.Table.Schema.O, node.Table.Name.O
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table,
},
false,
)
case *tidbast.CreateViewStmt:
// Not tracked as a changed table (risk/approval doesn't use views), but a qualified
// cross-database view is gated by its target database. SUP-222 / BYT-9698.
addTiDBObjectDatabase(changedResources, node.ViewName)
case *tidbast.CreateSequenceStmt:
addTiDBObjectDatabase(changedResources, node.Name)
case *tidbast.AlterSequenceStmt:
addTiDBObjectDatabase(changedResources, node.Name)
case *tidbast.DropSequenceStmt:
for _, seq := range node.Sequences {
addTiDBObjectDatabase(changedResources, seq)
}
case *tidbast.InsertStmt:
tables, err := extractTableRefs(node.Table)
if err != nil {
return errors.Wrap(err, "failed to extract table refs")
}
for _, table := range tables {
d := table.database
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table.table,
},
false,
)
}
case *tidbast.UpdateStmt:
tables, err := extractTableRefs(node.TableRefs)
if err != nil {
return errors.Wrap(err, "failed to extract table refs")
}
for _, table := range tables {
d := table.database
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table.table,
},
false,
)
}
case *tidbast.DeleteStmt:
tables, err := extractTableRefs(node.TableRefs)
if err != nil {
return errors.Wrap(err, "failed to extract table refs")
}
for _, table := range tables {
d := table.database
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table.table,
},
false,
)
}
if node.Tables != nil {
for _, table := range node.Tables.Tables {
d := table.Schema.O
if d == "" {
d = database
}
changedResources.AddTable(
d,
"",
&storepb.ChangedResourceTable{
Name: table.Name.O,
},
false,
)
}
}
case *tidbast.NonTransactionalDMLStmt:
if node.DryRun == tidbast.NoDryRun {
return getResourceChanges(database, node.DMLStmt, "", changedResources)
}
default:
}
return nil
}
func trimStatement(statement string) string {
return strings.TrimLeftFunc(strings.TrimRightFunc(statement, utils.IsSpaceOrSemicolon), unicode.IsSpace)
}
type table struct {
database string
table string
}
func extractResultSetNode(n tidbast.ResultSetNode) ([]table, error) {
if n == nil {
return nil, nil
}
switch n := n.(type) {
case *tidbast.SelectStmt:
return nil, nil
case *tidbast.SubqueryExpr:
return nil, nil
case *tidbast.TableSource:
return extractTableSource(n)
case *tidbast.TableName:
return extractTableName(n)
case *tidbast.Join:
return extractJoin(n)
case *tidbast.SetOprStmt:
return nil, nil
}
return nil, nil
}
func extractTableRefs(n *tidbast.TableRefsClause) ([]table, error) {
if n == nil {
return nil, nil
}
return extractJoin(n.TableRefs)
}
func extractJoin(n *tidbast.Join) ([]table, error) {
if n == nil {
return nil, nil
}
l, err := extractResultSetNode(n.Left)
if err != nil {
return nil, errors.Wrapf(err, "failed to extract left node in join")
}
r, err := extractResultSetNode(n.Right)
if err != nil {
return nil, errors.Wrapf(err, "failed to extract right node in join")
}
l = append(l, r...)
return l, nil
}
func extractTableSource(n *tidbast.TableSource) ([]table, error) {
if n == nil {
return nil, nil
}
return extractResultSetNode(n.Source)
}
func extractTableName(n *tidbast.TableName) ([]table, error) {
if n == nil {
return nil, nil
}
return []table{
{
table: n.Name.O,
database: n.Schema.O,
},
}, nil
}