Skip to content

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

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.go
index 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 advis
return 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.Advice
level storepb.Advice_Status
title string
format *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.go
new file mode 100644
index 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.go
deleted file mode 100644
index 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.go
index 19030c1759..998b84676d 100644
--- a/backend/plugin/parser/redshift/diagnose.go
+++ b/backend/plugin/parser/redshift/diagnose.go
@@ -2,11 +2,6 @@ package redshift
import (
"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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 5f9fa2d869..de9ff6541e 100644
--- a/backend/plugin/parser/redshift/query.go
+++ b/backend/plugin/parser/redshift/query.go
@@ -1,8 +1,7 @@
package redshift
import (
- "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 invalid
func 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, false
default:
- // 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.go
index b701715ec3..a7a1b281a6 100644
--- a/backend/plugin/parser/redshift/query_test.go
+++ b/backend/plugin/parser/redshift/query_test.go
@@ -1,9 +1,12 @@
package redshift
import (
+ "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.go
index 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 positions
stmts, 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 AST
var result []base.ParsedStatement
- astIndex := 0
for _, 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, nil
diff --git a/backend/plugin/parser/redshift/resource_change.go b/backend/plugin/parser/redshift/resource_change.go
index 7fc5bf01a8..515d89b04a 100644
--- a/backend/plugin/parser/redshift/resource_change.go
+++ b/backend/plugin/parser/redshift/resource_change.go
@@ -3,9 +3,8 @@ package redshift
import (
"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.go
new file mode 100644
index 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.go
index 5a8764ab1d..6640e29566 100644
--- a/backend/plugin/parser/redshift/split.go
+++ b/backend/plugin/parser/redshift/split.go
@@ -1,316 +1,39 @@
package redshift
import (
- "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 splitter
base.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.go
index 354cfdaa0b..57a5c12876 100644
--- a/backend/plugin/parser/redshift/statement_ranges.go
+++ b/backend/plugin/parser/redshift/statement_ranges.go
@@ -2,10 +2,10 @@ package redshift
import (
"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.go
new file mode 100644
index 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.go
index 3ff356d332..526f9b3b24 100644
--- a/backend/plugin/parser/redshift/statement_type.go
+++ b/backend/plugin/parser/redshift/statement_type.go
@@ -1,8 +1,9 @@
package redshift
import (
- "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) ([]StatementTypeWithPosition
var allResults []StatementTypeWithPosition
for _, 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.go
index 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 string
want []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)
+}