Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
chore: migrate redshift parser runtime to omni (#20542)
rebelice400416fdc429
diff --git a/backend/plugin/advisor/redshift/advisor_table_drop_naming_convention.go b/backend/plugin/advisor/redshift/advisor_table_drop_naming_convention.goindex 607e9ba82e..9c193ed9c5 100644--- a/backend/plugin/advisor/redshift/advisor_table_drop_naming_convention.go+++ b/backend/plugin/advisor/redshift/advisor_table_drop_naming_convention.go@@ -5,15 +5,13 @@ import ("fmt""regexp"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"-- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/redshift"+ redshiftast "github.com/bytebase/omni/redshift/ast""github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+ parserredshift "github.com/bytebase/bytebase/backend/plugin/parser/redshift")var (@@ -30,11 +28,6 @@ type TableDropNamingConventionAdvisor struct {// Check checks for table drop with naming convention.func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {- tree, err := getANTLRTree(checkCtx)- if err != nil {- return nil, err- }-level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)if err != nil {return nil, err@@ -50,87 +43,75 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisreturn nil, errors.Wrapf(err, "failed to compile regex format %q", namingPayload.Format)}- listener := &tableDropNamingConventionListener{+ checker := &tableDropNamingConventionChecker{level: level,title: checkCtx.Rule.Type.String(),format: format,adviceList: []*storepb.Advice{},}- antlr.ParseTreeWalkerDefault.Walk(listener, tree)+ for _, stmt := range checkCtx.ParsedStatements {+ node, ok := parserredshift.GetOmniNode(stmt.AST)+ if !ok {+ continue+ }+ checker.checkStmt(node, stmt.Start)+ }- return listener.adviceList, nil+ return checker.adviceList, nil}-type tableDropNamingConventionListener struct {- *parser.BaseRedshiftParserListener-+type tableDropNamingConventionChecker struct {adviceList []*storepb.Advicelevel storepb.Advice_Statustitle stringformat *regexp.Regexp}-// EnterDropstmt is called when entering a dropstmt rule.-func (l *tableDropNamingConventionListener) EnterDropstmt(ctx *parser.DropstmtContext) {- if ctx.DROP() == nil {+func (c *tableDropNamingConventionChecker) checkStmt(node redshiftast.Node, startPosition *storepb.Position) {+ dropStmt, ok := node.(*redshiftast.DropStmt)+ if !ok {return}-- // Check if this is a DROP TABLE statement- if ctx.Object_type_any_name() != nil && ctx.Object_type_any_name().TABLE() != nil {- // Extract table names from the drop statement- if ctx.Any_name_list() != nil {- for _, anyName := range ctx.Any_name_list().AllAny_name() {- tableName := getTableNameFromAnyName(anyName)- if tableName != "" && !l.format.MatchString(tableName) {- l.adviceList = append(l.adviceList, &storepb.Advice{- Status: l.level,- Code: code.TableDropNamingConventionMismatch.Int32(),- Title: l.title,- Content: fmt.Sprintf("`%s` mismatches drop table naming convention, naming format should be %q", tableName, l.format),- StartPosition: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{- Line: int32(ctx.GetStart().GetLine()),- Column: int32(ctx.GetStart().GetColumn()),- }, ctx.GetText()),- })- }- }+ if redshiftast.ObjectType(dropStmt.RemoveType) != redshiftast.OBJECT_TABLE {+ return+ }+ for _, tableName := range omniDropTableNames(dropStmt) {+ if tableName == "" || c.format.MatchString(tableName) {+ continue}+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: code.TableDropNamingConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("`%s` mismatches drop table naming convention, naming format should be %q", tableName, c.format),+ StartPosition: startPosition,+ })}}-func getTableNameFromAnyName(ctx parser.IAny_nameContext) string {- if ctx == nil {- return ""- }-- parts := []string{}-- // First part (could be schema or table)- if ctx.Colid() != nil {- parts = append(parts, normalizeRedshiftIdentifier(ctx.Colid().GetText()))+func omniDropTableNames(dropStmt *redshiftast.DropStmt) []string {+ if dropStmt.Objects == nil {+ return nil}- // Additional parts from attrs (qualified names like schema.table)- if ctx.Attrs() != nil {- for _, attr := range ctx.Attrs().AllAttr_name() {- parts = append(parts, normalizeRedshiftIdentifier(attr.GetText()))+ var result []string+ for _, item := range dropStmt.Objects.Items {+ var parts []string+ switch n := item.(type) {+ case *redshiftast.List:+ for _, nameItem := range n.Items {+ if s, ok := nameItem.(*redshiftast.String); ok {+ parts = append(parts, s.Str)+ }+ }+ case *redshiftast.RangeVar:+ parts = append(parts, n.Relname)+ default:+ }+ if len(parts) > 0 {+ result = append(result, parts[len(parts)-1])}}-- // Return the last part as the table name- if len(parts) > 0 {- return parts[len(parts)-1]- }-- return ""-}--func normalizeRedshiftIdentifier(name string) string {- // Remove quotes if present- if len(name) >= 2 && name[0] == '"' && name[len(name)-1] == '"' {- return name[1 : len(name)-1]- }- return name+ return result}diff --git a/backend/plugin/advisor/redshift/redshift_rules_test.go b/backend/plugin/advisor/redshift/redshift_rules_test.gonew file mode 100644index 0000000000..e4cef50534--- /dev/null+++ b/backend/plugin/advisor/redshift/redshift_rules_test.go@@ -0,0 +1,37 @@+package redshift++import (+ "context"+ "testing"++ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/component/sheet"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"+)++func TestRedshiftTableDropNamingConventionUsesOmniAST(t *testing.T) {+ sm := sheet.NewManager()+ rule := &storepb.SQLReviewRule{+ Type: storepb.SQLReviewRule_TABLE_DROP_NAMING_CONVENTION,+ Level: storepb.SQLReviewRule_WARNING,+ Payload: &storepb.SQLReviewRule_NamingPayload{+ NamingPayload: &storepb.SQLReviewRule_NamingRulePayload{+ Format: "_delete$",+ },+ },+ }++ adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, "DROP TABLE active;", []*storepb.SQLReviewRule{rule}, advisor.Context{+ DBType: storepb.Engine_REDSHIFT,+ NoAppendBuiltin: true,+ })++ require.NoError(t, err)+ require.Len(t, adviceList, 1)+ require.Equal(t, storepb.Advice_WARNING, adviceList[0].Status)+ require.Equal(t, code.TableDropNamingConventionMismatch.Int32(), adviceList[0].Code)+ require.Contains(t, adviceList[0].Content, "`active` mismatches drop table naming convention")+}diff --git a/backend/plugin/advisor/redshift/utils.go b/backend/plugin/advisor/redshift/utils.godeleted file mode 100644index cf588ca9e7..0000000000--- a/backend/plugin/advisor/redshift/utils.go+++ /dev/null@@ -1,30 +0,0 @@-package redshift--import (- "github.com/antlr4-go/antlr/v4"- "github.com/pkg/errors"-- "github.com/bytebase/bytebase/backend/plugin/advisor"- "github.com/bytebase/bytebase/backend/plugin/parser/base"-)--// getANTLRTree extracts a single ANTLR tree from the advisor context.-// Redshift advisors use a single parse tree instead of a list of ParseResults.-func getANTLRTree(checkCtx advisor.Context) (antlr.Tree, error) {- if checkCtx.ParsedStatements == nil {- return nil, errors.New("ParsedStatements is not provided in context")- }- if len(checkCtx.ParsedStatements) == 0 {- return nil, errors.New("ParsedStatements is empty")- }- // Redshift typically processes a single statement- stmt := checkCtx.ParsedStatements[0]- if stmt.AST == nil {- return nil, errors.New("AST is nil in ParsedStatement")- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- return nil, errors.New("AST type mismatch: expected ANTLR-based parser result")- }- return antlrAST.Tree, nil-}diff --git a/backend/plugin/parser/redshift/diagnose.go b/backend/plugin/parser/redshift/diagnose.goindex 19030c1759..998b84676d 100644--- a/backend/plugin/parser/redshift/diagnose.go+++ b/backend/plugin/parser/redshift/diagnose.go@@ -2,11 +2,6 @@ package redshiftimport ("context"- "strings"- "unicode"-- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/redshift""github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"@@ -27,40 +22,20 @@ func Diagnose(_ context.Context, _ base.DiagnoseContext, statement string) ([]ba}// parseRedshiftStatement parses the given SQL and returns syntax errors if any.-// Use the Redshift parser based on antlr4.func parseRedshiftStatement(statement string) *base.SyntaxError {- trimmedStatement := strings.TrimRightFunc(statement, unicode.IsSpace)- if len(trimmedStatement) > 0 && !strings.HasSuffix(trimmedStatement, ";") {- // Add a semicolon to the end of the statement to allow users to omit the semicolon- // for the last statement in the script.- statement += ";"- }- lexer := parser.NewRedshiftLexer(antlr.NewInputStream(statement))- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)- p := parser.NewRedshiftParser(stream)- lexerErrorListener := &base.ParseErrorListener{- Statement: statement,- }- lexer.RemoveErrorListeners()- lexer.AddErrorListener(lexerErrorListener)-- parserErrorListener := &base.ParseErrorListener{- Statement: statement,- }- p.RemoveErrorListeners()- p.AddErrorListener(parserErrorListener)-- p.BuildParseTrees = true-- p.Root()-- if lexerErrorListener.Err != nil {- return lexerErrorListener.Err+ stmt := base.Statement{+ Text: statement,+ Start: &store.Position{Line: 1, Column: 1},}-- if parserErrorListener.Err != nil {- return parserErrorListener.Err+ if _, err := ParseRedshiftOmni(statement); err != nil {+ syntaxErr, ok := convertOmniError(err, stmt).(*base.SyntaxError)+ if !ok {+ return &base.SyntaxError{+ Position: &store.Position{Line: 1, Column: 1},+ Message: err.Error(),+ }+ }+ return syntaxErr}-return nil}diff --git a/backend/plugin/parser/redshift/diagnose_test.go b/backend/plugin/parser/redshift/diagnose_test.gonew file mode 100644index 0000000000..703dd102ff--- /dev/null+++ b/backend/plugin/parser/redshift/diagnose_test.go@@ -0,0 +1,59 @@+package redshift++import (+ "context"+ "testing"++ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++func TestDiagnoseUsesOmniParseErrorPosition(t *testing.T) {+ tests := []struct {+ name string+ statement string+ line uint32+ }{+ {+ name: "single line",+ statement: "SELECT * FROM",+ line: 0,+ },+ {+ name: "second sql statement",+ statement: "SELECT 1;\n\nSELECT * FROM",+ line: 2,+ },+ {+ name: "line after non-ascii",+ statement: "SELECT '你好';\nSELECT * FROM",+ line: 1,+ },+ }++ for _, tc := range tests {+ t.Run(tc.name, func(t *testing.T) {+ diagnostics, err := Diagnose(context.Background(), base.DiagnoseContext{}, tc.statement)+ require.NoError(t, err)+ require.Len(t, diagnostics, 1)+ require.Equal(t, tc.line, diagnostics[0].Range.Start.Line)+ })+ }+}++func TestDiagnoseAcceptsRedshiftSyntax(t *testing.T) {+ tests := []string{+ "SELECT * FROM sales QUALIFY row_number() OVER () = 1;",+ "COPY sales FROM 's3://bucket/path' IAM_ROLE 'arn:aws:iam::123456789012:role/redshift';",+ "UNLOAD ('SELECT * FROM sales') TO 's3://bucket/out' IAM_ROLE 'arn:aws:iam::123456789012:role/redshift';",+ }++ for _, statement := range tests {+ t.Run(statement, func(t *testing.T) {+ diagnostics, err := Diagnose(context.Background(), base.DiagnoseContext{}, statement)+ require.NoError(t, err)+ require.Empty(t, diagnostics)+ })+ }+}diff --git a/backend/plugin/parser/redshift/omni.go b/backend/plugin/parser/redshift/omni.gonew file mode 100644index 0000000000..02b8cb7480--- /dev/null+++ b/backend/plugin/parser/redshift/omni.go@@ -0,0 +1,94 @@+package redshift++import (+ "errors"+ "fmt"+ "unicode/utf8"++ omniredshift "github.com/bytebase/omni/redshift"+ "github.com/bytebase/omni/redshift/ast"+ omniredshiftparser "github.com/bytebase/omni/redshift/parser"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++// OmniAST wraps an omni AST node and implements the base.AST interface.+type OmniAST struct {+ // Node is the omni AST node (e.g. *ast.SelectStmt, *ast.CreateStmt).+ Node ast.Node+ // Text is the original SQL text of this statement.+ Text string+ // StartPosition is the 1-based position where this statement starts.+ StartPosition *storepb.Position+}++// ASTStartPosition implements base.AST.+func (a *OmniAST) ASTStartPosition() *storepb.Position {+ return a.StartPosition+}++// ParseRedshiftOmni parses SQL using omni's parser.+func ParseRedshiftOmni(sql string) ([]omniredshift.Statement, error) {+ return omniredshift.Parse(sql)+}++// GetOmniNode extracts the omni AST node from a base.AST interface.+func GetOmniNode(a base.AST) (ast.Node, bool) {+ if a == nil {+ return nil, false+ }+ omniAST, ok := a.(*OmniAST)+ if !ok {+ return nil, false+ }+ return omniAST.Node, true+}++func convertOmniError(err error, stmt base.Statement) error {+ var parseErr *omniredshiftparser.ParseError+ if !errors.As(err, &parseErr) {+ return err+ }++ position := ByteOffsetToRunePosition(stmt.Text, parseErr.Position)+ if stmt.Start != nil {+ localLine := position.Line+ position.Line += stmt.Start.Line - 1+ if localLine == 1 {+ position.Column += stmt.Start.Column - 1+ }+ }+ return &base.SyntaxError{+ Position: position,+ Message: fmt.Sprintf("Syntax error at line %d: %s", position.Line, parseErr.Message),+ RawMessage: parseErr.Message,+ }+}++func ByteOffsetToRunePosition(sql string, byteOffset int) *storepb.Position {+ if byteOffset < 0 {+ byteOffset = 0+ }+ if byteOffset > len(sql) {+ byteOffset = len(sql)+ }++ line := int32(1)+ runeCol := int32(0)+ for i := 0; i < byteOffset; {+ r, size := utf8.DecodeRuneInString(sql[i:])+ if r == '\n' {+ line+++ runeCol = 0+ } else {+ runeCol+++ }+ i += size+ }++ return &storepb.Position{+ Line: line,+ Column: runeCol + 1,+ }+}diff --git a/backend/plugin/parser/redshift/omni_migration_test.go b/backend/plugin/parser/redshift/omni_migration_test.gonew file mode 100644index 0000000000..c04dc3d246--- /dev/null+++ b/backend/plugin/parser/redshift/omni_migration_test.go@@ -0,0 +1,83 @@+package redshift++import (+ "errors"+ "testing"++ redshiftast "github.com/bytebase/omni/redshift/ast"+ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++func TestParseStatementsUsesOmniAST(t *testing.T) {+ stmts, err := base.ParseStatements(storepb.Engine_REDSHIFT, "SELECT 1;")+ require.NoError(t, err)+ require.Len(t, stmts, 1)++ _, ok := stmts[0].AST.(*OmniAST)+ require.True(t, ok)++ _, ok = base.GetANTLRAST(stmts[0].AST)+ require.False(t, ok)+}++func TestParseStatementsUsesOmniASTForMultipleStatements(t *testing.T) {+ statement := "SELECT 1;\nINSERT INTO t VALUES (1);"++ stmts, err := base.ParseStatements(storepb.Engine_REDSHIFT, statement)+ require.NoError(t, err)+ require.Len(t, stmts, 2)++ firstNode, ok := GetOmniNode(stmts[0].AST)+ require.True(t, ok)+ require.IsType(t, &redshiftast.SelectStmt{}, firstNode)+ require.Equal(t, "SELECT 1;", stmts[0].Text)+ require.Equal(t, int32(1), stmts[0].Start.Line)+ require.Equal(t, int32(1), stmts[0].Start.Column)++ secondNode, ok := GetOmniNode(stmts[1].AST)+ require.True(t, ok)+ require.IsType(t, &redshiftast.InsertStmt{}, secondNode)+ require.Equal(t, "\nINSERT INTO t VALUES (1);", stmts[1].Text)+ require.Equal(t, int32(1), stmts[1].Start.Line)+ require.Equal(t, int32(10), stmts[1].Start.Column)+}++func TestParseStatementsOmniErrorUsesOriginalColumn(t *testing.T) {+ _, err := base.ParseStatements(storepb.Engine_REDSHIFT, "SELECT 1; SELECT * FROM")+ require.Error(t, err)++ var syntaxErr *base.SyntaxError+ require.True(t, errors.As(err, &syntaxErr))+ require.Equal(t, int32(1), syntaxErr.Position.Line)+ require.Equal(t, int32(24), syntaxErr.Position.Column)+}++func TestRedshiftOmniASTWrapper(t *testing.T) {+ node := &redshiftast.SelectStmt{}+ start := &storepb.Position{Line: 2, Column: 3}+ omniAST := &OmniAST{+ Node: node,+ Text: "SELECT 1",+ StartPosition: start,+ }++ var parsed base.AST = omniAST+ require.Equal(t, start, parsed.ASTStartPosition())++ got, ok := GetOmniNode(parsed)+ require.True(t, ok)+ require.Same(t, node, got)++ got, ok = GetOmniNode(nil)+ require.False(t, ok)+ require.Nil(t, got)+}++func TestRedshiftByteOffsetToRunePosition(t *testing.T) {+ position := ByteOffsetToRunePosition("SELECT\n日本 FROM t", len("SELECT\n日"))+ require.Equal(t, int32(2), position.Line)+ require.Equal(t, int32(2), position.Column)+}diff --git a/backend/plugin/parser/redshift/query.go b/backend/plugin/parser/redshift/query.goindex 5f9fa2d869..de9ff6541e 100644--- a/backend/plugin/parser/redshift/query.go+++ b/backend/plugin/parser/redshift/query.go@@ -1,8 +1,7 @@package redshiftimport (- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/redshift"+ redshiftast "github.com/bytebase/omni/redshift/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"@@ -23,204 +22,98 @@ func init() {// - returnsData: whether all queries return data// - error: parsing error if the statement is invalidfunc ValidateSQLForEditor(statement string) (bool, bool, error) {- // Parse the statement using the Redshift parser- parseResults, err := ParseRedshift(statement)+ omniStmts, err := ParseRedshiftOmni(statement)if err != nil {- return false, false, err+ return false, false, convertOmniError(err, base.Statement{+ Text: statement,+ Start: &storepb.Position{Line: 1, Column: 1},+ })}- // Create a validator listener to walk the parse tree- validator := &queryValidatorListener{- canRunInReadOnly: true,- returnsData: true,- }-- // Validate each statement- for _, parseResult := range parseResults {- antlr.ParseTreeWalkerDefault.Walk(validator, parseResult.Tree)- // If any statement fails validation, return immediately- if !validator.canRunInReadOnly {- break+ seen := false+ returnsData := true+ for _, stmt := range omniStmts {+ if stmt.Empty() {+ continue+ }+ seen = true+ canRunInReadOnly, stmtReturnsData := validateOmniEditorStatement(stmt.AST)+ if !canRunInReadOnly {+ return false, false, nil+ }+ if !stmtReturnsData {+ returnsData = false}}-- return validator.canRunInReadOnly, validator.returnsData, nil+ return seen, returnsData, nil}-type queryValidatorListener struct {- *parser.BaseRedshiftParserListener-- canRunInReadOnly bool- returnsData bool-}--// EnterStmt is called when entering a statement-func (l *queryValidatorListener) EnterStmt(ctx *parser.StmtContext) {- if ctx == nil {- return- }-- // Check each statement type- switch {- case ctx.Selectstmt() != nil:- // SELECT is allowed- return-- case ctx.Explainstmt() != nil:- // EXPLAIN is allowed, but check if it's EXPLAIN ANALYZE- if explainCtx, ok := ctx.Explainstmt().(*parser.ExplainstmtContext); ok {- l.handleExplainStmt(explainCtx)+func validateOmniEditorStatement(node redshiftast.Node) (bool, bool) {+ switch n := node.(type) {+ case *redshiftast.SelectStmt:+ if n.IntoClause != nil || hasOmniDMLInWithClause(n.WithClause) {+ return false, false}- return-- // SHOW statements - different types of SHOW commands- case ctx.Variableshowstmt() != nil,- ctx.Showcolumnsstmt() != nil,- ctx.Showdatabasesstmt() != nil,- ctx.Showdatasharesstmt() != nil,- ctx.Showexternaltablestmt() != nil,- ctx.Showgrantsstmt() != nil,- ctx.Showmodelstmt() != nil,- ctx.Showprocedurestmt() != nil,- ctx.Showschemasstmt() != nil,- ctx.Showtablestmt() != nil,- ctx.Showtablesstmt() != nil,- ctx.Showviewstmt() != nil:- // All SHOW statements are allowed and return data- return-- case ctx.Variablesetstmt() != nil:- // SET statements can run in read-only but don't return data- l.returnsData = false- return-- // DML statements are not allowed in read-only mode- case ctx.Insertstmt() != nil,- ctx.Updatestmt() != nil,- ctx.Deletestmt() != nil,- ctx.Truncatestmt() != nil:- l.canRunInReadOnly = false- l.returnsData = false- return-- // DDL statements are not allowed in read-only mode- case ctx.Createstmt() != nil,- ctx.Dropstmt() != nil,- ctx.Altertablestmt() != nil,- ctx.Indexstmt() != nil,- ctx.Createdbstmt() != nil,- ctx.Dropdbstmt() != nil,- ctx.Createfunctionstmt() != nil,- ctx.Createexternalfunctionstmt() != nil,- ctx.Createprocedurestmt() != nil,- ctx.Creatematviewstmt() != nil,- ctx.Createexternalviewstmt() != nil,- ctx.Createschemastmt() != nil,- ctx.Createuserstmt() != nil,- ctx.Createrolestmt() != nil,- ctx.Alteruserstmt() != nil,- ctx.Alterrolestmt() != nil,- ctx.Dropuserstmt() != nil,- ctx.Droprolestmt() != nil:- l.canRunInReadOnly = false- l.returnsData = false- return-- // Administrative statements are not allowed in read-only mode- case ctx.Grantstmt() != nil,- ctx.Revokestmt() != nil,- ctx.Analyzestmt() != nil,- ctx.Vacuumstmt() != nil,- ctx.Copystmt() != nil,- ctx.Commentstmt() != nil,- ctx.Callstmt() != nil:- l.canRunInReadOnly = false- l.returnsData = false- return-- // Transaction statements are not allowed in read-only mode- case ctx.Transactionstmt() != nil:- l.canRunInReadOnly = false- l.returnsData = false- return-+ return true, true+ case *redshiftast.ExplainStmt:+ if hasOmniExplainAnalyze(n) {+ if selectStmt, ok := n.Query.(*redshiftast.SelectStmt); ok && selectStmt.IntoClause == nil && !hasOmniDMLInWithClause(selectStmt.WithClause) {+ return true, false+ }+ return false, false+ }+ return true, true+ case *redshiftast.RedshiftShowStmt, *redshiftast.VariableShowStmt:+ return true, true+ case *redshiftast.VariableSetStmt:+ return true, falsedefault:- // For any unrecognized statement, be conservative and reject it- l.canRunInReadOnly = false- l.returnsData = false+ return false, false}}-// handleExplainStmt handles EXPLAIN statements-func (l *queryValidatorListener) handleExplainStmt(ctx *parser.ExplainstmtContext) {- if ctx == nil {- return+func hasOmniExplainAnalyze(stmt *redshiftast.ExplainStmt) bool {+ if stmt == nil || stmt.Options == nil {+ return false}-- // Check if it's EXPLAIN ANALYZE by looking for the Analyze_keyword- if ctx.Analyze_keyword() != nil {- // EXPLAIN ANALYZE actually executes the query- // Check what statement is being explained using AST- if explainableStmt := ctx.Explainablestmt(); explainableStmt != nil {- // Use type assertion to check the actual explainable statement- if explainableCtx, ok := explainableStmt.(*parser.ExplainablestmtContext); ok {- // Check if it's a SELECT statement using the AST- if explainableCtx.Selectstmt() != nil {- // EXPLAIN ANALYZE SELECT is allowed in read-only but doesn't return data- l.returnsData = false- } else {- // EXPLAIN ANALYZE of non-SELECT (INSERT/UPDATE/DELETE/DECLARE CURSOR) is not allowed- l.canRunInReadOnly = false- l.returnsData = false- }- }+ for _, item := range stmt.Options.Items {+ def, ok := item.(*redshiftast.DefElem)+ if !ok {+ continue}- }- // Regular EXPLAIN (without ANALYZE) is always allowed and returns data-}--// EnterCommon_table_expr is called when entering a CTE-func (l *queryValidatorListener) EnterCommon_table_expr(ctx *parser.Common_table_exprContext) {- if ctx != nil {- // Check if the CTE contains DML statements- if l.hasDMLInContext(ctx) {- l.canRunInReadOnly = false- l.returnsData = false+ if def.Defname == "analyze" {+ return true}}+ return false}-// hasDMLInContext checks if the given context contains DML statements-func (*queryValidatorListener) hasDMLInContext(ctx antlr.ParseTree) bool {- if ctx == nil {+func hasOmniDMLInWithClause(withClause *redshiftast.WithClause) bool {+ if withClause == nil || withClause.Ctes == nil {return false}-- // Create a DML detector listener- dmlDetector := &dmlDetectorListener{- hasDML: false,+ for _, item := range withClause.Ctes.Items {+ cte, ok := item.(*redshiftast.CommonTableExpr)+ if !ok {+ continue+ }+ if hasOmniDMLNode(cte.Ctequery) {+ return true+ }}-- antlr.ParseTreeWalkerDefault.Walk(dmlDetector, ctx)- return dmlDetector.hasDML+ return false}-type dmlDetectorListener struct {- *parser.BaseRedshiftParserListener- hasDML bool-}--// Check for DELETE statement-func (l *dmlDetectorListener) EnterDeletestmt(_ *parser.DeletestmtContext) {- l.hasDML = true-}--// Check for INSERT statement-func (l *dmlDetectorListener) EnterInsertstmt(_ *parser.InsertstmtContext) {- l.hasDML = true-}--// Check for UPDATE statement-func (l *dmlDetectorListener) EnterUpdatestmt(_ *parser.UpdatestmtContext) {- l.hasDML = true+func hasOmniDMLNode(node redshiftast.Node) bool {+ hasDML := false+ redshiftast.Inspect(node, func(n redshiftast.Node) bool {+ switch n.(type) {+ case *redshiftast.InsertStmt, *redshiftast.UpdateStmt, *redshiftast.DeleteStmt, *redshiftast.MergeStmt:+ hasDML = true+ return false+ default:+ return !hasDML+ }+ })+ return hasDML}diff --git a/backend/plugin/parser/redshift/query_test.go b/backend/plugin/parser/redshift/query_test.goindex b701715ec3..a7a1b281a6 100644--- a/backend/plugin/parser/redshift/query_test.go+++ b/backend/plugin/parser/redshift/query_test.go@@ -1,9 +1,12 @@package redshiftimport (+ "errors""testing""github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/plugin/parser/base")func TestValidateSQLForEditor(t *testing.T) {@@ -518,3 +521,13 @@ func TestValidateSQLForEditor(t *testing.T) {})}}++func TestValidateSQLForEditorReturnsSyntaxError(t *testing.T) {+ _, _, err := ValidateSQLForEditor("SELEC * FORM users")+ require.Error(t, err)++ var syntaxErr *base.SyntaxError+ require.True(t, errors.As(err, &syntaxErr))+ require.NotNil(t, syntaxErr.Position)+ require.Equal(t, int32(1), syntaxErr.Position.Line)+}diff --git a/backend/plugin/parser/redshift/redshift.go b/backend/plugin/parser/redshift/redshift.goindex b084d9c245..6bac0415a1 100644--- a/backend/plugin/parser/redshift/redshift.go+++ b/backend/plugin/parser/redshift/redshift.go@@ -20,30 +20,35 @@ func init() {// parseRedshiftStatements is the ParseStatementsFunc for Redshift.// Returns []ParsedStatement with both text and AST populated.func parseRedshiftStatements(statement string) ([]base.ParsedStatement, error) {- // First split to get Statement with text and positionsstmts, err := SplitSQL(statement)if err != nil {return nil, err}- // Then parse to get ASTs- parseResults, err := ParseRedshift(statement)- if err != nil {- return nil, err- }-- // Combine: Statement provides text/positions, ANTLRAST provides ASTvar result []base.ParsedStatement- astIndex := 0for _, stmt := range stmts {- ps := base.ParsedStatement{- Statement: stmt,+ if stmt.Empty {+ result = append(result, base.ParsedStatement{Statement: stmt})+ continue+ }++ omniStmts, err := ParseRedshiftOmni(stmt.Text)+ if err != nil {+ return nil, convertOmniError(err, stmt)}- if !stmt.Empty && astIndex < len(parseResults) {- ps.AST = parseResults[astIndex]- astIndex+++ for _, omniStmt := range omniStmts {+ if omniStmt.Empty() {+ continue+ }+ result = append(result, base.ParsedStatement{+ Statement: stmt,+ AST: &OmniAST{+ Node: omniStmt.AST,+ Text: stmt.Text,+ StartPosition: stmt.Start,+ },+ })}- result = append(result, ps)}return result, nildiff --git a/backend/plugin/parser/redshift/resource_change.go b/backend/plugin/parser/redshift/resource_change.goindex 7fc5bf01a8..515d89b04a 100644--- a/backend/plugin/parser/redshift/resource_change.go+++ b/backend/plugin/parser/redshift/resource_change.go@@ -3,9 +3,8 @@ package redshiftimport ("strings"- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/redshift"- "github.com/pkg/errors"+ omniredshift "github.com/bytebase/omni/redshift"+ redshiftast "github.com/bytebase/omni/redshift/ast""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -17,318 +16,53 @@ func init() {base.RegisterExtractChangedResourcesFunc(storepb.Engine_REDSHIFT, extractChangedResources)}-func extractChangedResources(database string, _ string, dbMetadata *model.DatabaseMetadata, asts []base.AST, _ string) (*base.ChangeSummary, error) {+func extractChangedResources(database string, schema string, dbMetadata *model.DatabaseMetadata, _ []base.AST, statement string) (*base.ChangeSummary, error) {+ omniSummary, err := omniredshift.ExtractChangedResources(statement, database, schema)+ if err != nil {+ return nil, err+ }+changedResources := model.NewChangedResources(dbMetadata)- listener := &resourceChangeListener{- currentDatabase: database,- changedResources: changedResources,- dbMetadata: dbMetadata,- searchPath: []string{"public"}, // Default search path for Redshift+ for _, table := range omniSummary.Tables {+ changedResources.AddTable(+ table.Database,+ table.Schema,+ &storepb.ChangedResourceTable{+ Name: table.Name,+ },+ table.Affected,+ )}- for _, ast := range asts {- antlrAST, ok := base.GetANTLRAST(ast)- if !ok {- return nil, errors.New("expected ANTLR AST for Redshift")- }- antlr.ParseTreeWalkerDefault.Walk(listener, antlrAST.Tree)+ sampleDMLs, err := extractOmniSampleDMLs(statement)+ if err != nil {+ return nil, err}return &base.ChangeSummary{ChangedResources: changedResources,- SampleDMLS: listener.sampleDMLs,- DMLCount: listener.dmlCount,- InsertCount: listener.insertCount,+ SampleDMLS: sampleDMLs,+ DMLCount: omniSummary.DMLCount,+ InsertCount: omniSummary.InsertCount,}, nil}-type resourceChangeListener struct {- *parser.BaseRedshiftParserListener-- currentDatabase string- changedResources *model.ChangedResources- dbMetadata *model.DatabaseMetadata- searchPath []string- sampleDMLs []string- dmlCount int- insertCount int-}--// EnterCreatestmt is called when entering a createstmt rule (CREATE TABLE).-func (l *resourceChangeListener) EnterCreatestmt(ctx *parser.CreatestmtContext) {- if ctx.Table_name() == nil {- return- }-- tableName := extractTableName(ctx.Table_name())- schemaName := extractSchemaFromTableName(ctx.Table_name(), l.searchPath[0])-- l.changedResources.AddTable(- l.currentDatabase,- schemaName,- &storepb.ChangedResourceTable{- Name: tableName,- },- false, // affectedTable- )-}--// EnterDropstmt is called when entering a dropstmt rule.-func (l *resourceChangeListener) EnterDropstmt(ctx *parser.DropstmtContext) {- if ctx.DROP() == nil {- return- }-- // Handle DROP TABLE- if ctx.Object_type_any_name() != nil && ctx.Object_type_any_name().TABLE() != nil {- if ctx.Any_name_list() != nil {- for _, anyName := range ctx.Any_name_list().AllAny_name() {- tableName := extractAnyName(anyName)- schemaName := extractSchemaFromAnyName(anyName, l.searchPath[0])- // For DROP TABLE, we mark it as removed- l.changedResources.AddTable(- l.currentDatabase,- schemaName,- &storepb.ChangedResourceTable{- Name: tableName,- },- true, // affectedTable - true means it's being dropped- )- }- }- }-- // Handle DROP INDEX- // Note: Drop_type_name is used for different drop types, not indexes- // TODO: Find correct way to detect DROP INDEX in Redshift parser and implement index tracking-}--// EnterAltertablestmt is called when entering an altertablestmt rule.-func (l *resourceChangeListener) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {- if ctx.ALTER() == nil || ctx.TABLE() == nil || ctx.Qualified_name() == nil {- return- }-- tableName := extractQualifiedName(ctx.Qualified_name())- schemaName := extractSchemaName(ctx.Qualified_name(), l.searchPath[0])-- // For ALTER TABLE, we add it as an affected table- l.changedResources.AddTable(- l.currentDatabase,- schemaName,- &storepb.ChangedResourceTable{- Name: tableName,- },- true, // affectedTable- )-}--// EnterIndexstmt is called when entering an indexstmt rule (CREATE INDEX).-func (*resourceChangeListener) EnterIndexstmt(ctx *parser.IndexstmtContext) {- if ctx.CREATE() == nil || ctx.INDEX() == nil {- return- }-- // For CREATE INDEX, we need to track which table it affects- // TODO: Extract table name from index statement context- // For now, we skip index tracking-}--// EnterVariablesetstmt is called when entering a variablesetstmt rule.-func (l *resourceChangeListener) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {- if ctx.SET() == nil {- return- }-- // Check for SET search_path- if ctx.Set_rest() != nil && ctx.Set_rest().GetText() != "" {- text := strings.ToLower(ctx.Set_rest().GetText())- if strings.Contains(text, "search_path") {- // Extract the new search path value- // This is a simplified implementation - in production you'd want more robust parsing- if strings.Contains(text, "=") {- parts := strings.Split(text, "=")- if len(parts) > 1 {- pathValue := strings.TrimSpace(parts[1])- pathValue = strings.Trim(pathValue, "'\"")- schemas := strings.Split(pathValue, ",")- l.searchPath = make([]string, 0, len(schemas))- for _, schema := range schemas {- schema = strings.TrimSpace(schema)- if schema != "" {- l.searchPath = append(l.searchPath, schema)- }- }- if len(l.searchPath) == 0 {- l.searchPath = []string{"public"}- }- }- }- }- }-}--// DML statement handlers-func (l *resourceChangeListener) EnterInsertstmt(ctx *parser.InsertstmtContext) {- if ctx.INSERT() == nil {- return- }- l.dmlCount++- l.insertCount++- if len(l.sampleDMLs) < common.MaximumLintExplainSize {- l.sampleDMLs = append(l.sampleDMLs, ctx.GetText())- }-}--func (l *resourceChangeListener) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {- if ctx.UPDATE() == nil {- return- }- l.dmlCount++- if len(l.sampleDMLs) < common.MaximumLintExplainSize {- l.sampleDMLs = append(l.sampleDMLs, ctx.GetText())- }-}--func (l *resourceChangeListener) EnterDeletestmt(ctx *parser.DeletestmtContext) {- if ctx.DELETE_P() == nil {- return- }- l.dmlCount++- if len(l.sampleDMLs) < common.MaximumLintExplainSize {- l.sampleDMLs = append(l.sampleDMLs, ctx.GetText())- }-}--// Helper functions to extract names from various contexts-func extractQualifiedName(ctx parser.IQualified_nameContext) string {- if ctx == nil {- return ""- }-- parts := []string{}- if ctx.Colid() != nil {- parts = append(parts, normalizeRedshiftIdentifierText(ctx.Colid().GetText()))- }-- if ctx.Indirection() != nil {- for _, el := range ctx.Indirection().AllIndirection_el() {- if el.Attr_name() != nil {- parts = append(parts, normalizeRedshiftIdentifierText(el.Attr_name().GetText()))- }- }- }-- if len(parts) > 0 {- return parts[len(parts)-1]- }- return ""-}--func extractSchemaName(ctx parser.IQualified_nameContext, defaultSchema string) string {- if ctx == nil {- return defaultSchema- }-- parts := []string{}- if ctx.Colid() != nil {- parts = append(parts, normalizeRedshiftIdentifierText(ctx.Colid().GetText()))+func extractOmniSampleDMLs(statement string) ([]string, error) {+ stmts, err := ParseRedshiftOmni(statement)+ if err != nil {+ return nil, err}- if ctx.Indirection() != nil {- for _, el := range ctx.Indirection().AllIndirection_el() {- if el.Attr_name() != nil {- parts = append(parts, normalizeRedshiftIdentifierText(el.Attr_name().GetText()))- }+ var sampleDMLs []string+ for _, stmt := range stmts {+ if len(sampleDMLs) >= common.MaximumLintExplainSize {+ break}- }-- // If we have more than one part, the first part is the schema- if len(parts) > 1 {- return parts[0]- }- return defaultSchema-}--func extractAnyName(ctx parser.IAny_nameContext) string {- if ctx == nil {- return ""- }-- parts := []string{}- if ctx.Colid() != nil {- parts = append(parts, normalizeRedshiftIdentifierText(ctx.Colid().GetText()))- }-- if ctx.Attrs() != nil {- for _, attr := range ctx.Attrs().AllAttr_name() {- parts = append(parts, normalizeRedshiftIdentifierText(attr.GetText()))+ switch stmt.AST.(type) {+ case *redshiftast.InsertStmt, *redshiftast.UpdateStmt, *redshiftast.DeleteStmt, *redshiftast.MergeStmt:+ sampleDMLs = append(sampleDMLs, strings.TrimSpace(stmt.Text))+ default:}}-- if len(parts) > 0 {- return parts[len(parts)-1]- }- return ""-}--func extractSchemaFromAnyName(ctx parser.IAny_nameContext, defaultSchema string) string {- if ctx == nil {- return defaultSchema- }-- parts := []string{}- if ctx.Colid() != nil {- parts = append(parts, normalizeRedshiftIdentifierText(ctx.Colid().GetText()))- }-- if ctx.Attrs() != nil {- for _, attr := range ctx.Attrs().AllAttr_name() {- parts = append(parts, normalizeRedshiftIdentifierText(attr.GetText()))- }- }-- // If we have more than one part, the first part is the schema- if len(parts) > 1 {- return parts[0]- }- return defaultSchema-}--// Helper function to extract table name-func extractTableName(ctx parser.ITable_nameContext) string {- if ctx == nil {- return ""- }-- // Check qualified name first- if ctx.Qualified_name() != nil {- return extractQualifiedName(ctx.Qualified_name())- }-- // Check temporary table name- if ctx.Temporary_table_name() != nil {- // For temporary tables, just return the text- return normalizeRedshiftIdentifierText(ctx.Temporary_table_name().GetText())- }-- return ""-}--func extractSchemaFromTableName(ctx parser.ITable_nameContext, defaultSchema string) string {- if ctx == nil {- return defaultSchema- }-- // Check qualified name first- if ctx.Qualified_name() != nil {- return extractSchemaName(ctx.Qualified_name(), defaultSchema)- }-- // Temporary tables are typically in a special schema- if ctx.Temporary_table_name() != nil {- return "pg_temp"- }-- return defaultSchema+ return sampleDMLs, nil}diff --git a/backend/plugin/parser/redshift/resource_change_test.go b/backend/plugin/parser/redshift/resource_change_test.gonew file mode 100644index 0000000000..ea68c3396a--- /dev/null+++ b/backend/plugin/parser/redshift/resource_change_test.go@@ -0,0 +1,93 @@+package redshift++import (+ "testing"++ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/store/model"+)++func TestExtractChangedResources(t *testing.T) {+ statement := `CREATE TABLE t1 (c1 INT);+ALTER TABLE t1 ADD COLUMN c2 INT;+INSERT INTO t1 VALUES (1);+UPDATE t1 SET c2 = 2;`++ dbMetadata := model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{}, []byte{}, &storepb.DatabaseConfig{}, storepb.Engine_REDSHIFT, true /* caseSensitive */)+ changedResources := model.NewChangedResources(dbMetadata)+ changedResources.AddTable(+ "db",+ "public",+ &storepb.ChangedResourceTable{+ Name: "t1",+ },+ true,+ )+ want := &base.ChangeSummary{+ ChangedResources: changedResources,+ SampleDMLS: []string{+ "INSERT INTO t1 VALUES (1);",+ "UPDATE t1 SET c2 = 2;",+ },+ DMLCount: 2,+ InsertCount: 1,+ }++ stmts, err := base.ParseStatements(storepb.Engine_REDSHIFT, statement)+ require.NoError(t, err)+ got, err := base.ExtractChangedResources(storepb.Engine_REDSHIFT, "db", "public", dbMetadata, base.ExtractASTs(stmts), statement)+ require.NoError(t, err)+ require.Equal(t, want, got)+}++func TestExtractChangedResourcesSearchPathDropAndSelectInto(t *testing.T) {+ statement := `SET search_path TO analytics;+CREATE TABLE unqualified(id INT);+SELECT * INTO copied_rows FROM public.rows;+DROP TABLE old_rows;+DELETE FROM copied_rows WHERE id = 1;`++ dbMetadata := model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{}, []byte{}, &storepb.DatabaseConfig{}, storepb.Engine_REDSHIFT, true /* caseSensitive */)+ changedResources := model.NewChangedResources(dbMetadata)+ changedResources.AddTable(+ "db",+ "analytics",+ &storepb.ChangedResourceTable{+ Name: "unqualified",+ },+ false,+ )+ changedResources.AddTable(+ "db",+ "analytics",+ &storepb.ChangedResourceTable{+ Name: "copied_rows",+ },+ true,+ )+ changedResources.AddTable(+ "db",+ "analytics",+ &storepb.ChangedResourceTable{+ Name: "old_rows",+ },+ true,+ )+ want := &base.ChangeSummary{+ ChangedResources: changedResources,+ SampleDMLS: []string{+ "DELETE FROM copied_rows WHERE id = 1;",+ },+ DMLCount: 1,+ InsertCount: 0,+ }++ stmts, err := base.ParseStatements(storepb.Engine_REDSHIFT, statement)+ require.NoError(t, err)+ got, err := base.ExtractChangedResources(storepb.Engine_REDSHIFT, "db", "public", dbMetadata, base.ExtractASTs(stmts), statement)+ require.NoError(t, err)+ require.Equal(t, want, got)+}diff --git a/backend/plugin/parser/redshift/split.go b/backend/plugin/parser/redshift/split.goindex 5a8764ab1d..6640e29566 100644--- a/backend/plugin/parser/redshift/split.go+++ b/backend/plugin/parser/redshift/split.go@@ -1,316 +1,39 @@package redshiftimport (- "log/slog"+ omniredshift "github.com/bytebase/omni/redshift"- "github.com/antlr4-go/antlr/v4"- "github.com/pkg/errors"-- parser "github.com/bytebase/parser/redshift"-- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base")func init() {- // Unregister the PostgreSQL splitter for Redshift- // and register the Redshift-specific splitterbase.RegisterSplitterFunc(storepb.Engine_REDSHIFT, SplitSQL)}// SplitSQL splits the given SQL statement into multiple SQL statements.func SplitSQL(statement string) ([]base.Statement, error) {- lexer := parser.NewRedshiftLexer(antlr.NewInputStream(statement))- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)- list, err := splitSQLImpl(stream, statement)- if err != nil {- slog.Info("failed to split Redshift statement", "statement", statement)- // Use parser to split statement.- return splitByParser(statement, lexer, stream)- }- return list, nil-}--func splitByParser(statement string, lexer *parser.RedshiftLexer, stream *antlr.CommonTokenStream) ([]base.Statement, error) {- p := parser.NewRedshiftParser(stream)- lexerErrorListener := &base.ParseErrorListener{- Statement: statement,- }- lexer.RemoveErrorListeners()- lexer.AddErrorListener(lexerErrorListener)-- parserErrorListener := &base.ParseErrorListener{- Statement: statement,- }- p.RemoveErrorListeners()- p.AddErrorListener(parserErrorListener)-- p.BuildParseTrees = true-- tree := p.Root()- if lexerErrorListener.Err != nil {- return nil, lexerErrorListener.Err- }-- if parserErrorListener.Err != nil {- return nil, parserErrorListener.Err- }-- if tree == nil || tree.Stmtblock() == nil || tree.Stmtblock().Stmtmulti() == nil {- return nil, errors.New("failed to split multiple statements")- }-- var result []base.Statement- tokens := stream.GetAllTokens()-- byteOffset := 0- start := 0- for _, semi := range tree.Stmtblock().Stmtmulti().AllSEMI() {- pos := semi.GetSymbol().GetStart()- stmtText := stream.GetTextFromTokens(tokens[start], tokens[pos])- stmtByteLength := len(stmtText)-- // Calculate start position from byte offset (first character of Text)- startLine, startColumn := base.CalculateLineAndColumn(statement, byteOffset)- result = append(result, base.Statement{- Text: stmtText,- Range: &storepb.Range{- Start: int32(byteOffset),- End: int32(byteOffset + stmtByteLength),- },- End: common.ConvertANTLRTokenToExclusiveEndPosition(- int32(tokens[pos].GetLine()),- int32(tokens[pos].GetColumn()),- tokens[pos].GetText(),- ),+ segments := omniredshift.Split(statement)+ list := make([]base.Statement, 0, len(segments))+ for _, segment := range segments {+ startLine, startColumn := base.CalculateLineAndColumn(statement, segment.ByteStart)+ endLine, endColumn := base.CalculateLineAndColumn(statement, segment.ByteEnd)+ list = append(list, base.Statement{+ Text: segment.Text,+ Empty: segment.Empty(),Start: &storepb.Position{Line: int32(startLine + 1),Column: int32(startColumn + 1),},- Empty: base.IsEmpty(tokens[start:pos+1], parser.RedshiftParserSEMI),- })- byteOffset += stmtByteLength- start = pos + 1- }- // For the last statement, it may not end with semicolon symbol, EOF symbol instead.- eofPos := len(tokens) - 1- if start < eofPos {- stmtText := stream.GetTextFromTokens(tokens[start], tokens[eofPos-1])- stmtByteLength := len(stmtText)-- // Calculate start position from byte offset (first character of Text)- startLine, startColumn := base.CalculateLineAndColumn(statement, byteOffset)- result = append(result, base.Statement{- Text: stmtText,- Range: &storepb.Range{- Start: int32(byteOffset),- End: int32(byteOffset + stmtByteLength),- },- End: common.ConvertANTLRTokenToExclusiveEndPosition(- int32(tokens[eofPos-1].GetLine()),- int32(tokens[eofPos-1].GetColumn()),- tokens[eofPos-1].GetText(),- ),- Start: &storepb.Position{- Line: int32(startLine + 1),- Column: int32(startColumn + 1),+ End: &storepb.Position{+ Line: int32(endLine + 1),+ Column: int32(endColumn + 1),},- Empty: base.IsEmpty(tokens[start:eofPos], parser.RedshiftParserSEMI),- })- }- return result, nil-}--type openParenthesis struct {- tokenType int- pos int-}--func splitSQLImpl(stream *antlr.CommonTokenStream, statement string) ([]base.Statement, error) {- var result []base.Statement- stream.Fill()- tokens := stream.GetAllTokens()-- var beginCaseStack, ifStack, loopStack []openParenthesis- var semicolonStack []int-- for i, token := range tokens {- switch token.GetTokenType() {- case parser.RedshiftParserBEGIN_P:- if isBeginTransaction(tokens, i) {- continue- }-- beginCaseStack = append(beginCaseStack, openParenthesis{- tokenType: token.GetTokenType(),- pos: i,- })- case parser.RedshiftParserCASE:- beginCaseStack = append(beginCaseStack, openParenthesis{- tokenType: token.GetTokenType(),- pos: i,- })- case parser.RedshiftParserIF_P:- ifStack = append(ifStack, openParenthesis{- tokenType: token.GetTokenType(),- pos: i,- })- case parser.RedshiftParserLOOP:- loopStack = append(loopStack, openParenthesis{- tokenType: token.GetTokenType(),- pos: i,- })- case parser.RedshiftParserSEMI:- semicolonStack = append(semicolonStack, i)- case parser.RedshiftParserEND_P:- if isEndTransaction(tokens, i) {- continue- }-- nextToken := base.GetDefaultChannelTokenType(tokens, i, 1)- switch nextToken {- case parser.RedshiftParserIF_P:- if len(ifStack) == 0 {- return nil, errors.New("invalid statement: failed to split multiple statements")- }- // There are two cases:- // 1. The IF statement with END IF statement.- // 2. The IF statement without END IF statement.- // We should match the longest IF statement, so we should check the first IF statement in the stack.- semicolonStack = popSemicolonStack(semicolonStack, ifStack[0].pos)- ifStack = ifStack[:len(ifStack)-1]- case parser.RedshiftParserLOOP:- if len(loopStack) == 0 {- return nil, errors.New("invalid statement: failed to split multiple statements")- }- semicolonStack = popSemicolonStack(semicolonStack, loopStack[len(semicolonStack)-1].pos)- loopStack = loopStack[:len(loopStack)-1]- case parser.RedshiftParserCASE:- if len(beginCaseStack) == 0 {- return nil, errors.New("invalid statement: failed to split multiple statements")- }- semicolonStack = popSemicolonStack(semicolonStack, beginCaseStack[len(beginCaseStack)-1].pos)- beginCaseStack = beginCaseStack[:len(beginCaseStack)-1]- default:- if len(beginCaseStack) == 0 {- return nil, errors.New("invalid statement: failed to split multiple statements")- }- semicolonStack = popSemicolonStack(semicolonStack, beginCaseStack[len(beginCaseStack)-1].pos)- beginCaseStack = beginCaseStack[:len(beginCaseStack)-1]- }- default:- }- }-- byteOffset := 0- start := 0- for _, pos := range semicolonStack {- stmtText := stream.GetTextFromTokens(tokens[start], tokens[pos])- stmtByteLength := len(stmtText)-- // Calculate start position from byte offset (first character of Text)- startLine, startColumn := base.CalculateLineAndColumn(statement, byteOffset)- result = append(result, base.Statement{- Text: stmtText,- Range: &storepb.Range{- Start: int32(byteOffset),- End: int32(byteOffset + stmtByteLength),- },- End: common.ConvertANTLRTokenToExclusiveEndPosition(- int32(tokens[pos].GetLine()),- int32(tokens[pos].GetColumn()),- tokens[pos].GetText(),- ),- Start: &storepb.Position{- Line: int32(startLine + 1),- Column: int32(startColumn + 1),- },- Empty: base.IsEmpty(tokens[start:pos+1], parser.RedshiftParserSEMI),- })- byteOffset += stmtByteLength- start = pos + 1- }- // For the last statement, it may not end with semicolon symbol, EOF symbol instead.- eofPos := len(tokens) - 1- if start < eofPos {- stmtText := stream.GetTextFromTokens(tokens[start], tokens[eofPos-1])- stmtByteLength := len(stmtText)-- // Calculate start position from byte offset (first character of Text)- startLine, startColumn := base.CalculateLineAndColumn(statement, byteOffset)- result = append(result, base.Statement{- Text: stmtText,Range: &storepb.Range{- Start: int32(byteOffset),- End: int32(byteOffset + stmtByteLength),- },- End: common.ConvertANTLRTokenToExclusiveEndPosition(- int32(tokens[eofPos-1].GetLine()),- int32(tokens[eofPos-1].GetColumn()),- tokens[eofPos-1].GetText(),- ),- Start: &storepb.Position{- Line: int32(startLine + 1),- Column: int32(startColumn + 1),+ Start: int32(segment.ByteStart),+ End: int32(segment.ByteEnd),},- Empty: base.IsEmpty(tokens[start:eofPos], parser.RedshiftParserSEMI),})}-- return result, nil-}--func popSemicolonStack(semicolonStack []int, pos int) []int {- if len(semicolonStack) == 0 {- return semicolonStack- }-- for i := len(semicolonStack) - 1; i >= 0; i-- {- if semicolonStack[i] < pos {- return semicolonStack[:i+1]- }- }-- return []int{}-}--func isEndTransaction(tokens []antlr.Token, index int) bool {- if tokens[index].GetTokenType() != parser.RedshiftLexerEND_P {- return false- }-- switch base.GetDefaultChannelTokenType(tokens, index, 1) {- case parser.RedshiftParserTRANSACTION,- parser.RedshiftParserWORK,- parser.RedshiftParserSEMI:- return true- case parser.RedshiftParserAND:- if base.GetDefaultChannelTokenType(tokens, index, 2) == parser.RedshiftParserNO {- return base.GetDefaultChannelTokenType(tokens, index, 3) == parser.RedshiftParserCHAIN- }- return base.GetDefaultChannelTokenType(tokens, index, 2) == parser.RedshiftParserCHAIN- default:- return false- }-}--func isBeginTransaction(tokens []antlr.Token, index int) bool {- if tokens[index].GetTokenType() != parser.RedshiftLexerBEGIN_P {- return false- }-- switch base.GetDefaultChannelTokenType(tokens, index, 1) {- case parser.RedshiftParserTRANSACTION,- parser.RedshiftParserWORK,- parser.RedshiftParserSEMI,- parser.RedshiftParserISOLATION,- parser.RedshiftParserREAD,- parser.RedshiftLexerDEFERRABLE:- return true- case parser.RedshiftParserNOT:- return base.GetDefaultChannelTokenType(tokens, index, 2) == parser.RedshiftParserDEFERRABLE- default:- return false- }+ return list, nil}diff --git a/backend/plugin/parser/redshift/statement_ranges.go b/backend/plugin/parser/redshift/statement_ranges.goindex 354cfdaa0b..57a5c12876 100644--- a/backend/plugin/parser/redshift/statement_ranges.go+++ b/backend/plugin/parser/redshift/statement_ranges.go@@ -2,10 +2,10 @@ package redshiftimport ("context"- "strings"- "unicode"+ "unicode/utf8"lsp "github.com/bytebase/lsp-protocol"+ omniredshift "github.com/bytebase/omni/redshift"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"@@ -16,78 +16,83 @@ func init() {}func GetStatementRanges(_ context.Context, _ base.StatementRangeContext, statement string) ([]base.Range, error) {- ranges := getSQLStatementRangesUTF16Position([]byte(statement))- return ranges, nil-}--func getSQLStatementRangesUTF16Position(content []byte) []lsp.Range {- s := strings.TrimRightFunc(string(content), unicode.IsSpace)- // Assuming the content is UTF-8 encoded.- statements := strings.Split(s, ";")+ omniRanges, err := omniredshift.StatementRanges(statement)+ if err == nil {+ ranges := make([]base.Range, 0, len(omniRanges))+ for _, r := range omniRanges {+ ranges = append(ranges, base.Range{+ Start: lsp.Position{+ Line: uint32(r.Start.Line),+ Character: uint32(r.Start.Character),+ },+ End: lsp.Position{+ Line: uint32(r.End.Line),+ Character: uint32(r.End.Character),+ },+ })+ }+ return ranges, nil+ }- var ranges []lsp.Range- // 0-based UTF-16 encoded line and character.- line, character := 0, 0+ return getLexicalStatementRanges(statement)+}- for i, statement := range statements {- // Trim left space to provide more accurate range.- statement = strings.TrimLeftFunc(statement, func(r rune) bool {- if !unicode.IsSpace(r) {- return false- }- if r == '\n' {- line++- character = 0- } else {- // Check rune utf16 length by BMP.- if r <= 0xFFFF {- character++- } else {- character += 2- }- }- return true- })+func getLexicalStatementRanges(statement string) ([]base.Range, error) {+ statements, err := SplitSQL(statement)+ if err != nil {+ return nil, err+ }+ if len(statements) == 0 {+ return nil, nil+ }- // If the statement is empty, skip it.- if statement == "" {+ positions := buildUTF16PositionMap(statement)+ ranges := make([]base.Range, 0, len(statements))+ for _, stmt := range statements {+ if stmt.Empty || stmt.Range == nil {continue}-- begin := lsp.Position{Line: uint32(line), Character: uint32(character)}- for _, r := range statement {- if r == '\n' {- line++- character = 0- } else {- // Check rune utf16 length by BMP.- if r <= 0xFFFF {- character++- } else {- character += 2- }- }+ start := int(stmt.Range.Start)+ end := int(stmt.Range.End)+ startPos, ok := positionAtByteOffset(positions, start)+ if !ok {+ continue+ }+ endPos, ok := positionAtByteOffset(positions, end)+ if !ok {+ continue}+ ranges = append(ranges, base.Range{+ Start: startPos,+ End: endPos,+ })+ }+ return ranges, nil+}- endLine, endCharacter := line, character- // End is exclusive, so we check the next byte.- if i == len(statements)-1 {- // End of the content.- endLine++- endCharacter = 0+func buildUTF16PositionMap(sql string) []lsp.Position {+ positions := make([]lsp.Position, len(sql)+1)+ var line, character uint32+ for i := 0; i < len(sql); {+ positions[i] = lsp.Position{Line: line, Character: character}+ r, size := utf8.DecodeRuneInString(sql[i:])+ if r == '\n' {+ line+++ character = 0+ } else if r > 0xFFFF {+ character += 2} else {- // Next byte is ';', include it.character++- endCharacter++- if nextStatement := statements[i+1]; len(nextStatement) > 0 && nextStatement[0] == '\n' {- endLine++- endCharacter = 0- } else {- endCharacter++- }}- end := lsp.Position{Line: uint32(endLine), Character: uint32(endCharacter)}- ranges = append(ranges, lsp.Range{Start: begin, End: end})+ i += size+ }+ positions[len(sql)] = lsp.Position{Line: line, Character: character}+ return positions+}++func positionAtByteOffset(positions []lsp.Position, byteOffset int) (lsp.Position, bool) {+ if byteOffset < 0 || byteOffset >= len(positions) {+ return lsp.Position{}, false}- return ranges+ return positions[byteOffset], true}diff --git a/backend/plugin/parser/redshift/statement_ranges_test.go b/backend/plugin/parser/redshift/statement_ranges_test.gonew file mode 100644index 0000000000..b6f8c03a0c--- /dev/null+++ b/backend/plugin/parser/redshift/statement_ranges_test.go@@ -0,0 +1,63 @@+package redshift++import (+ "context"+ "testing"++ lsp "github.com/bytebase/lsp-protocol"+ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++func TestGetStatementRanges(t *testing.T) {+ tests := []struct {+ name string+ statement string+ want []base.Range+ }{+ {+ name: "multi statement",+ statement: "SELECT 1;\n SELECT 2;",+ want: []base.Range{+ {+ Start: lsp.Position{Line: 0, Character: 0},+ End: lsp.Position{Line: 0, Character: 9},+ },+ {+ Start: lsp.Position{Line: 1, Character: 2},+ End: lsp.Position{Line: 1, Character: 11},+ },+ },+ },+ {+ name: "utf16 comment prefix",+ statement: "/*🙂*/ SELECT 1;",+ want: []base.Range{+ {+ Start: lsp.Position{Line: 0, Character: 7},+ End: lsp.Position{Line: 0, Character: 16},+ },+ },+ },+ }++ for _, tc := range tests {+ t.Run(tc.name, func(t *testing.T) {+ got, err := GetStatementRanges(context.Background(), base.StatementRangeContext{}, tc.statement)+ require.NoError(t, err)+ require.Equal(t, tc.want, got)+ })+ }+}++func TestGetStatementRangesToleratesIncompleteSQL(t *testing.T) {+ got, err := GetStatementRanges(context.Background(), base.StatementRangeContext{}, "SELECT * FROM")+ require.NoError(t, err)+ require.Equal(t, []base.Range{+ {+ Start: lsp.Position{Line: 0, Character: 0},+ End: lsp.Position{Line: 0, Character: 13},+ },+ }, got)+}diff --git a/backend/plugin/parser/redshift/statement_type.go b/backend/plugin/parser/redshift/statement_type.goindex 3ff356d332..526f9b3b24 100644--- a/backend/plugin/parser/redshift/statement_type.go+++ b/backend/plugin/parser/redshift/statement_type.go@@ -1,8 +1,9 @@package redshiftimport (- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/redshift"+ "strings"++ redshiftast "github.com/bytebase/omni/redshift/ast""github.com/pkg/errors"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -27,21 +28,30 @@ func GetStatementTypesWithPosition(asts []base.AST) ([]StatementTypeWithPositionvar allResults []StatementTypeWithPositionfor _, unifiedAST := range asts {- antlrAST, ok := base.GetANTLRAST(unifiedAST)+ omniAST, ok := unifiedAST.(*OmniAST)if !ok {- return nil, errors.New("expected ANTLR AST for Redshift")+ return nil, errors.New("expected Redshift omni AST")+ }+ if omniAST.Node == nil {+ continue}- if antlrAST.Tree == nil {- return nil, errors.New("ANTLR tree is nil")++ stmtType := classifyOmniStatementType(omniAST.Node)+ if stmtType == storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED {+ continue}- collector := &statementTypeCollectorWithPosition{- tokens: antlrAST.Tokens,- baseLine: base.GetLineOffset(antlrAST.StartPosition),+ line := 0+ if omniAST.StartPosition != nil {+ line = int(omniAST.StartPosition.Line)}+ line += strings.Count(omniAST.Text, "\n")- antlr.ParseTreeWalkerDefault.Walk(collector, antlrAST.Tree)- allResults = append(allResults, collector.results...)+ allResults = append(allResults, StatementTypeWithPosition{+ Type: stmtType,+ Line: line,+ Text: omniAST.Text,+ })}return allResults, nil@@ -61,278 +71,131 @@ func GetStatementTypes(asts []base.AST) ([]storepb.StatementType, error) {return types, nil}-// statementTypeCollectorWithPosition collects statement types with positions.-type statementTypeCollectorWithPosition struct {- *parser.BaseRedshiftParserListener- tokens *antlr.CommonTokenStream- baseLine int- results []StatementTypeWithPosition-}--// Helper function to add statement with position.-func (c *statementTypeCollectorWithPosition) addStatement(stmtType storepb.StatementType, ctx antlr.ParserRuleContext) {- if stmtType == storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED {- return- }-- // Get line number from the stop token- line := 0- if ctx.GetStop() != nil {- line = ctx.GetStop().GetLine() + c.baseLine- }-- // Get statement text- text := ""- if c.tokens != nil && ctx.GetStart() != nil && ctx.GetStop() != nil {- text = c.tokens.GetTextFromInterval(antlr.NewInterval(- ctx.GetStart().GetTokenIndex(),- ctx.GetStop().GetTokenIndex(),- ))- }-- c.results = append(c.results, StatementTypeWithPosition{- Type: stmtType,- Line: line,- Text: text,- })-}--// isTopLevel checks if the context is at top level.-func isTopLevel(ctx antlr.Tree) bool {- if ctx == nil {- return true- }-- switch ctx := ctx.(type) {- case *parser.RootContext, *parser.StmtblockContext:- return true- case *parser.StmtmultiContext, *parser.StmtContext:- return isTopLevel(ctx.GetParent())+func classifyOmniStatementType(node redshiftast.Node) storepb.StatementType {+ switch n := node.(type) {+ case *redshiftast.CreateStmt:+ return storepb.StatementType_CREATE_TABLE+ case *redshiftast.CreateTableAsStmt:+ if n.Objtype == redshiftast.OBJECT_MATVIEW {+ return storepb.StatementType_CREATE_VIEW+ }+ return storepb.StatementType_CREATE_TABLE+ case *redshiftast.ViewStmt:+ return storepb.StatementType_CREATE_VIEW+ case *redshiftast.IndexStmt:+ return storepb.StatementType_CREATE_INDEX+ case *redshiftast.CreateSeqStmt:+ return storepb.StatementType_CREATE_SEQUENCE+ case *redshiftast.CreateSchemaStmt:+ return storepb.StatementType_CREATE_SCHEMA+ case *redshiftast.CreateFunctionStmt:+ return storepb.StatementType_CREATE_FUNCTION+ case *redshiftast.CreatedbStmt:+ return storepb.StatementType_CREATE_DATABASE+ case *redshiftast.DropdbStmt:+ return storepb.StatementType_DROP_DATABASE+ case *redshiftast.DropStmt:+ return classifyOmniDropStatementType(redshiftast.ObjectType(n.RemoveType))+ case *redshiftast.AlterTableStmt:+ if redshiftast.ObjectType(n.ObjType) == redshiftast.OBJECT_VIEW || redshiftast.ObjectType(n.ObjType) == redshiftast.OBJECT_MATVIEW {+ return storepb.StatementType_ALTER_VIEW+ }+ return storepb.StatementType_ALTER_TABLE+ case *redshiftast.AlterSeqStmt:+ return storepb.StatementType_ALTER_SEQUENCE+ case *redshiftast.RenameStmt:+ return classifyOmniRenameStatementType(n.RenameType)+ case *redshiftast.CommentStmt:+ return storepb.StatementType_COMMENT+ case *redshiftast.TruncateStmt:+ return storepb.StatementType_TRUNCATE+ case *redshiftast.InsertStmt:+ return storepb.StatementType_INSERT+ case *redshiftast.UpdateStmt:+ return storepb.StatementType_UPDATE+ case *redshiftast.DeleteStmt:+ return storepb.StatementType_DELETE+ case *redshiftast.RedshiftObjectStmt:+ return classifyOmniRedshiftObjectStatementType(n.Command, n.ObjectType)default:- return false- }-}--// CREATE TABLE statements-func (c *statementTypeCollectorWithPosition) EnterCreatestmt(ctx *parser.CreatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_TABLE, ctx)-}--// CREATE VIEW statements-func (c *statementTypeCollectorWithPosition) EnterViewstmt(ctx *parser.ViewstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_VIEW, ctx)-}--// CREATE MATERIALIZED VIEW statements-func (c *statementTypeCollectorWithPosition) EnterCreatematviewstmt(ctx *parser.CreatematviewstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_VIEW, ctx)-}--// CREATE INDEX statements-func (c *statementTypeCollectorWithPosition) EnterIndexstmt(ctx *parser.IndexstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_INDEX, ctx)-}--// CREATE SEQUENCE statements-func (c *statementTypeCollectorWithPosition) EnterCreateseqstmt(ctx *parser.CreateseqstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_SEQUENCE, ctx)-}--// CREATE SCHEMA statements-func (c *statementTypeCollectorWithPosition) EnterCreateschemastmt(ctx *parser.CreateschemastmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_SCHEMA, ctx)-}--// CREATE FUNCTION statements-func (c *statementTypeCollectorWithPosition) EnterCreatefunctionstmt(ctx *parser.CreatefunctionstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_FUNCTION, ctx)-}--// CREATE DATABASE statements-func (c *statementTypeCollectorWithPosition) EnterCreatedbstmt(ctx *parser.CreatedbstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_CREATE_DATABASE, ctx)-}--// DROP statements-func (c *statementTypeCollectorWithPosition) EnterDropstmt(ctx *parser.DropstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(getDropStatementType(ctx), ctx)-}--// ALTER statements-func (c *statementTypeCollectorWithPosition) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_ALTER_TABLE, ctx)-}--// ALTER MATERIALIZED VIEW statements-func (c *statementTypeCollectorWithPosition) EnterAltermaterializedviewstmt(ctx *parser.AltermaterializedviewstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_ALTER_VIEW, ctx)-}--// ALTER EXTERNAL VIEW statements-func (c *statementTypeCollectorWithPosition) EnterAlterexternalviewstmt(ctx *parser.AlterexternalviewstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_ALTER_VIEW, ctx)-}--func (c *statementTypeCollectorWithPosition) EnterAlterseqstmt(ctx *parser.AlterseqstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_ALTER_SEQUENCE, ctx)-}--// RENAME statements-func (c *statementTypeCollectorWithPosition) EnterRenamestmt(ctx *parser.RenamestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }-- // Check for top-level RENAME operations- if ctx.INDEX() != nil {- c.addStatement(storepb.StatementType_RENAME_INDEX, ctx)- return- }- if ctx.SCHEMA() != nil {- c.addStatement(storepb.StatementType_RENAME_SCHEMA, ctx)- return- }- if ctx.SEQUENCE() != nil {- c.addStatement(storepb.StatementType_RENAME_SEQUENCE, ctx)- return- }-- // All other RENAME operations- if ctx.VIEW() != nil {- c.addStatement(storepb.StatementType_ALTER_VIEW, ctx)- } else if ctx.TABLE() != nil {- c.addStatement(storepb.StatementType_ALTER_TABLE, ctx)- }-}--// COMMENT statements-func (c *statementTypeCollectorWithPosition) EnterCommentstmt(ctx *parser.CommentstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_COMMENT, ctx)-}--// DROP FUNCTION statements-func (c *statementTypeCollectorWithPosition) EnterRemovefuncstmt(ctx *parser.RemovefuncstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_DROP_FUNCTION, ctx)-}--// DROP DATABASE statements-func (c *statementTypeCollectorWithPosition) EnterDropdbstmt(ctx *parser.DropdbstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_DROP_DATABASE, ctx)-}--func (c *statementTypeCollectorWithPosition) EnterTruncatestmt(ctx *parser.TruncatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_TRUNCATE, ctx)-}--// DROP SCHEMA statements-func (c *statementTypeCollectorWithPosition) EnterDropschemastmt(ctx *parser.DropschemastmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_DROP_SCHEMA, ctx)-}--// DML statements-func (c *statementTypeCollectorWithPosition) EnterInsertstmt(ctx *parser.InsertstmtContext) {- if !isTopLevel(ctx.GetParent()) {- return- }- c.addStatement(storepb.StatementType_INSERT, ctx)-}--func (c *statementTypeCollectorWithPosition) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}- c.addStatement(storepb.StatementType_UPDATE, ctx)}-func (c *statementTypeCollectorWithPosition) EnterDeletestmt(ctx *parser.DeletestmtContext) {- if !isTopLevel(ctx.GetParent()) {- return+func classifyOmniDropStatementType(objectType redshiftast.ObjectType) storepb.StatementType {+ switch objectType {+ case redshiftast.OBJECT_TABLE:+ return storepb.StatementType_DROP_TABLE+ case redshiftast.OBJECT_VIEW:+ return storepb.StatementType_DROP_VIEW+ case redshiftast.OBJECT_MATVIEW:+ return storepb.StatementType_DROP_TABLE+ case redshiftast.OBJECT_SCHEMA:+ return storepb.StatementType_DROP_SCHEMA+ case redshiftast.OBJECT_INDEX:+ return storepb.StatementType_DROP_INDEX+ case redshiftast.OBJECT_SEQUENCE:+ return storepb.StatementType_DROP_SEQUENCE+ case redshiftast.OBJECT_FUNCTION:+ return storepb.StatementType_DROP_FUNCTION+ default:+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}- c.addStatement(storepb.StatementType_DELETE, ctx)}-// getDropStatementType determines the specific DROP statement type.-func getDropStatementType(ctx *parser.DropstmtContext) storepb.StatementType {- if ctx == nil {+func classifyOmniRenameStatementType(objectType redshiftast.ObjectType) storepb.StatementType {+ switch objectType {+ case redshiftast.OBJECT_INDEX:+ return storepb.StatementType_RENAME_INDEX+ case redshiftast.OBJECT_SCHEMA:+ return storepb.StatementType_RENAME_SCHEMA+ case redshiftast.OBJECT_SEQUENCE:+ return storepb.StatementType_RENAME_SEQUENCE+ case redshiftast.OBJECT_VIEW, redshiftast.OBJECT_MATVIEW:+ return storepb.StatementType_ALTER_VIEW+ case redshiftast.OBJECT_TABLE:+ return storepb.StatementType_ALTER_TABLE+ default:return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}+}- // Check object_type_any_name (TABLE, SEQUENCE, VIEW, INDEX, etc.)- if ctx.Object_type_any_name() != nil {- objType := ctx.Object_type_any_name()- if objType.TABLE() != nil {- return storepb.StatementType_DROP_TABLE- }- if objType.VIEW() != nil {- if objType.MATERIALIZED() != nil {- // DROP MATERIALIZED VIEW holds data — treat as DROP_TABLE for risk assessment.- return storepb.StatementType_DROP_TABLE- }- return storepb.StatementType_DROP_VIEW+func classifyOmniRedshiftObjectStatementType(command, objectType string) storepb.StatementType {+ switch strings.ToLower(command) {+ case "create":+ switch strings.ToLower(objectType) {+ case "database":+ return storepb.StatementType_CREATE_DATABASE+ case "schema", "external schema":+ return storepb.StatementType_CREATE_SCHEMA+ default:+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}- if objType.INDEX() != nil {- return storepb.StatementType_DROP_INDEX+ case "alter":+ switch strings.ToLower(objectType) {+ case "database":+ return storepb.StatementType_ALTER_DATABASE+ case "index":+ return storepb.StatementType_ALTER_INDEX+ case "sequence":+ return storepb.StatementType_ALTER_SEQUENCE+ case "table":+ return storepb.StatementType_ALTER_TABLE+ case "view", "external view", "materialized view":+ return storepb.StatementType_ALTER_VIEW+ default:+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}- if objType.SEQUENCE() != nil {- return storepb.StatementType_DROP_SEQUENCE+ case "drop":+ switch strings.ToLower(objectType) {+ case "database":+ return storepb.StatementType_DROP_DATABASE+ case "schema", "external schema":+ return storepb.StatementType_DROP_SCHEMA+ default:+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}+ default:return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}-- // Note: DROP SCHEMA is handled by DropschemastmtContext, not DropstmtContext- return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}diff --git a/backend/plugin/parser/redshift/statement_type_test.go b/backend/plugin/parser/redshift/statement_type_test.goindex 36ca574528..813aca0fe6 100644--- a/backend/plugin/parser/redshift/statement_type_test.go+++ b/backend/plugin/parser/redshift/statement_type_test.go@@ -15,6 +15,111 @@ func TestGetStatementTypes(t *testing.T) {statement stringwant []storepb.StatementType}{+ {+ name: "create table",+ statement: "CREATE TABLE t1 (id INT);",+ want: []storepb.StatementType{+ storepb.StatementType_CREATE_TABLE,+ },+ },+ {+ name: "create table as select",+ statement: "CREATE TABLE t1 AS SELECT 1;",+ want: []storepb.StatementType{+ storepb.StatementType_CREATE_TABLE,+ },+ },+ {+ name: "create view",+ statement: "CREATE VIEW v1 AS SELECT 1;",+ want: []storepb.StatementType{+ storepb.StatementType_CREATE_VIEW,+ },+ },+ {+ name: "create materialized view",+ statement: "CREATE MATERIALIZED VIEW mv1 AS SELECT 1;",+ want: []storepb.StatementType{+ storepb.StatementType_CREATE_VIEW,+ },+ },+ {+ name: "create index",+ statement: "CREATE INDEX idx_t1_id ON t1(id);",+ want: []storepb.StatementType{+ storepb.StatementType_CREATE_INDEX,+ },+ },+ {+ name: "create sequence",+ statement: "CREATE SEQUENCE seq1;",+ want: []storepb.StatementType{+ storepb.StatementType_CREATE_SEQUENCE,+ },+ },+ {+ name: "create schema",+ statement: "CREATE SCHEMA s1;",+ want: []storepb.StatementType{+ storepb.StatementType_CREATE_SCHEMA,+ },+ },+ {+ name: "create database",+ statement: "CREATE DATABASE db1;",+ want: []storepb.StatementType{+ storepb.StatementType_CREATE_DATABASE,+ },+ },+ {+ name: "drop table",+ statement: "DROP TABLE t1;",+ want: []storepb.StatementType{+ storepb.StatementType_DROP_TABLE,+ },+ },+ {+ name: "drop view",+ statement: "DROP VIEW v1;",+ want: []storepb.StatementType{+ storepb.StatementType_DROP_VIEW,+ },+ },+ {+ name: "drop materialized view",+ statement: "DROP MATERIALIZED VIEW mv1;",+ want: []storepb.StatementType{+ storepb.StatementType_DROP_TABLE,+ },+ },+ {+ name: "drop schema",+ statement: "DROP SCHEMA s1;",+ want: []storepb.StatementType{+ storepb.StatementType_DROP_SCHEMA,+ },+ },+ {+ name: "alter table",+ statement: "ALTER TABLE t1 ADD COLUMN name TEXT;",+ want: []storepb.StatementType{+ storepb.StatementType_ALTER_TABLE,+ },+ },+ {+ name: "alter datashare",+ statement: "ALTER DATASHARE salesshare ADD SCHEMA public;",+ want: []storepb.StatementType{},+ },+ {+ name: "insert update delete",+ statement: "INSERT INTO t1 VALUES (1); UPDATE t1 SET id = 2; DELETE FROM t1;",+ want: []storepb.StatementType{+ storepb.StatementType_INSERT,+ storepb.StatementType_UPDATE,+ storepb.StatementType_DELETE,+ },+ },{name: "truncate table",statement: "TRUNCATE TABLE t1;",@@ -22,6 +127,13 @@ func TestGetStatementTypes(t *testing.T) {storepb.StatementType_TRUNCATE,},},+ {+ name: "comment",+ statement: "COMMENT ON TABLE t1 IS 'hello';",+ want: []storepb.StatementType{+ storepb.StatementType_COMMENT,+ },+ },}for _, tt := range tests {@@ -35,3 +147,22 @@ func TestGetStatementTypes(t *testing.T) {})}}++func TestGetStatementTypesWithPosition(t *testing.T) {+ statement := `CREATE TABLE t1 (id INT);+DROP TABLE t2;+INSERT INTO t1 VALUES (1);`+ stmts, err := base.ParseStatements(storepb.Engine_REDSHIFT, statement)+ require.NoError(t, err)++ got, err := GetStatementTypesWithPosition(base.ExtractASTs(stmts))+ require.NoError(t, err)+ require.Len(t, got, 3)+ require.Equal(t, storepb.StatementType_CREATE_TABLE, got[0].Type)+ require.Equal(t, 1, got[0].Line)+ require.Equal(t, "CREATE TABLE t1 (id INT);", got[0].Text)+ require.Equal(t, storepb.StatementType_DROP_TABLE, got[1].Type)+ require.Equal(t, 2, got[1].Line)+ require.Equal(t, storepb.StatementType_INSERT, got[2].Type)+ require.Equal(t, 3, got[2].Line)+}