Skip to content

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

11.5 KB
Raw Blame
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
}