Skip to content

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

refactor: unify syntax check functions in parser registry (#17772)

Danny Xu27f9f2ba0f9a
diff --git a/backend/component/sheet/sheet.go b/backend/component/sheet/sheet.go
index e57548f2c7..0330839644 100644
--- a/backend/component/sheet/sheet.go
+++ b/backend/component/sheet/sheet.go
@@ -2,11 +2,8 @@ package sheet
import (
"context"
- "fmt"
"io"
"log/slog"
- "regexp"
- "strconv"
"strings"
"sync"
"time"
@@ -15,25 +12,23 @@ import (
"github.com/pkg/errors"
"github.com/zeebo/xxh3"
- tidbparser "github.com/pingcap/tidb/pkg/parser"
- tidbast "github.com/pingcap/tidb/pkg/parser/ast"
-
"github.com/bytebase/bytebase/backend/common"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- crparser "github.com/bytebase/bytebase/backend/plugin/parser/cockroachdb"
- "github.com/bytebase/bytebase/backend/plugin/parser/doris"
- mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql"
- partiqlparser "github.com/bytebase/bytebase/backend/plugin/parser/partiql"
pgrawparser "github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy"
- "github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"
- plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql"
- redshiftparser "github.com/bytebase/bytebase/backend/plugin/parser/redshift"
- snowsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/snowflake"
- tidbbbparser "github.com/bytebase/bytebase/backend/plugin/parser/tidb"
- tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql"
tsqlbatch "github.com/bytebase/bytebase/backend/plugin/parser/tsql/batch"
"github.com/bytebase/bytebase/backend/store"
+
+ // Import parsers to register their parse functions.
+ _ "github.com/bytebase/bytebase/backend/plugin/parser/cockroachdb"
+ _ "github.com/bytebase/bytebase/backend/plugin/parser/doris"
+ _ "github.com/bytebase/bytebase/backend/plugin/parser/mysql"
+ _ "github.com/bytebase/bytebase/backend/plugin/parser/partiql"
+ _ "github.com/bytebase/bytebase/backend/plugin/parser/plsql"
+ _ "github.com/bytebase/bytebase/backend/plugin/parser/redshift"
+ _ "github.com/bytebase/bytebase/backend/plugin/parser/snowflake"
+ _ "github.com/bytebase/bytebase/backend/plugin/parser/tidb"
+ _ "github.com/bytebase/bytebase/backend/plugin/parser/tsql"
)
const (
@@ -218,413 +213,47 @@ func (sm *Manager) GetASTsForChecks(dbType storepb.Engine, statement string) (an
if result.ast != nil || result.advices != nil {
return result.ast, result.advices
}
- result.ast, result.advices = syntaxCheck(dbType, statement)
- return result.ast, result.advices
-}
-
-func syntaxCheck(dbType storepb.Engine, statement string) (any, []*storepb.Advice) {
- switch dbType {
- case storepb.Engine_TIDB:
- return tidbSyntaxCheck(statement)
- case storepb.Engine_MYSQL, storepb.Engine_MARIADB, storepb.Engine_OCEANBASE:
- return mysqlSyntaxCheck(statement)
- case storepb.Engine_POSTGRES:
- return postgresSyntaxCheck(statement)
- case storepb.Engine_REDSHIFT:
- return redshiftSyntaxCheck(statement)
- case storepb.Engine_ORACLE:
- return oracleSyntaxCheck(statement)
- case storepb.Engine_SNOWFLAKE:
- return snowflakeSyntaxCheck(statement)
- case storepb.Engine_MSSQL:
- return mssqlSyntaxCheck(statement)
- case storepb.Engine_DYNAMODB:
- return partiqlSyntaxCheck(statement)
- case storepb.Engine_COCKROACHDB:
- return cockroachdbSyntaxCheck(statement)
- case storepb.Engine_DORIS:
- return dorisSyntaxCheck(statement)
- default:
- // Return default advice for unsupported database types
- }
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_ERROR,
- Code: InternalErrorCode,
- Title: "Unsupported database type",
- Content: fmt.Sprintf("Unsupported database type %s", dbType),
- StartPosition: nil,
- },
- }
-}
-
-func dorisSyntaxCheck(statement string) (any, []*storepb.Advice) {
- result, err := doris.ParseDorisSQL(statement)
+ ast, err := base.Parse(dbType, statement)
if err != nil {
- if syntaxErr, ok := err.(*base.SyntaxError); ok {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: StatementSyntaxErrorCode,
- Title: SyntaxErrorTitle,
- Content: syntaxErr.Message,
- StartPosition: syntaxErr.Position,
- },
- }
- }
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: InternalErrorCode,
- Title: "Parse error",
- Content: err.Error(),
- StartPosition: nil,
- },
- }
- }
-
- if result == nil {
- return nil, nil
- }
- return result, nil
-}
-
-func cockroachdbSyntaxCheck(statement string) (any, []*storepb.Advice) {
- result, err := crparser.ParseCockroachDBSQL(statement)
- if err != nil {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: InternalErrorCode,
- Title: "Parse error",
- Content: err.Error(),
- StartPosition: nil,
- },
- }
- }
-
- if result == nil {
- return nil, nil
- }
- return result.Stmts, nil
-}
-
-func partiqlSyntaxCheck(statement string) (any, []*storepb.Advice) {
- result, err := partiqlparser.ParsePartiQL(statement)
- if err != nil {
- if syntaxErr, ok := err.(*base.SyntaxError); ok {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: StatementSyntaxErrorCode,
- Title: SyntaxErrorTitle,
- Content: syntaxErr.Message,
- StartPosition: syntaxErr.Position,
- },
- }
- }
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: InternalErrorCode,
- Title: "Parse error",
- Content: err.Error(),
- StartPosition: nil,
- },
- }
- }
-
- if result == nil {
- return nil, nil
- }
- return result.Tree, nil
-}
-
-func mssqlSyntaxCheck(statement string) (any, []*storepb.Advice) {
- result, err := tsqlparser.ParseTSQL(statement)
- if err != nil {
- if syntaxErr, ok := err.(*base.SyntaxError); ok {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: StatementSyntaxErrorCode,
- Title: SyntaxErrorTitle,
- Content: syntaxErr.Message,
- StartPosition: syntaxErr.Position,
- },
- }
- }
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: InternalErrorCode,
- Title: "Parse error",
- Content: err.Error(),
- StartPosition: nil,
- },
- }
- }
-
- if result == nil {
- return nil, nil
- }
- return result.Tree, nil
-}
-
-func snowflakeSyntaxCheck(statement string) (any, []*storepb.Advice) {
- result, err := snowsqlparser.ParseSnowSQL(statement + ";")
- if err != nil {
- if syntaxErr, ok := err.(*base.SyntaxError); ok {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: StatementSyntaxErrorCode,
- Title: SyntaxErrorTitle,
- Content: syntaxErr.Message,
- StartPosition: syntaxErr.Position,
- },
- }
- }
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: InternalErrorCode,
- Title: "Parse error",
- Content: err.Error(),
- StartPosition: nil,
- },
- }
- }
- if result == nil {
- return nil, nil
+ result.advices = convertErrorToAdvice(err)
+ } else {
+ result.ast = ast
}
- return result.Tree, nil
+ return result.ast, result.advices
}
-func oracleSyntaxCheck(statement string) (any, []*storepb.Advice) {
- tree, _, err := plsqlparser.ParsePLSQL(statement + ";")
- if err != nil {
- if syntaxErr, ok := err.(*base.SyntaxError); ok {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: StatementSyntaxErrorCode,
- Title: SyntaxErrorTitle,
- Content: syntaxErr.Message,
- StartPosition: syntaxErr.Position,
- },
- }
- }
- return nil, []*storepb.Advice{
+func convertErrorToAdvice(err error) []*storepb.Advice {
+ if syntaxErr, ok := err.(*base.SyntaxError); ok {
+ return []*storepb.Advice{
{
- Status: storepb.Advice_WARNING,
- Code: InternalErrorCode,
- Title: "Parse error",
- Content: err.Error(),
- StartPosition: nil,
+ Status: storepb.Advice_ERROR,
+ Code: StatementSyntaxErrorCode,
+ Title: SyntaxErrorTitle,
+ Content: syntaxErr.Message,
+ StartPosition: syntaxErr.Position,
},
}
}
- return tree, nil
-}
-
-func postgresSyntaxCheck(statement string) (any, []*storepb.Advice) {
- nodes, err := pgrawparser.Parse(pgrawparser.ParseContext{}, statement)
- if err != nil {
- if _, ok := err.(*pgrawparser.ConvertError); ok {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_ERROR,
- Code: InternalErrorCode,
- Title: "Parser conversion error",
- Content: err.Error(),
- StartPosition: &storepb.Position{
- Line: int32(calculatePostgresErrorLine(statement)),
- },
- },
- }
- }
- return nil, []*storepb.Advice{
+ if _, ok := err.(*pgrawparser.ConvertError); ok {
+ return []*storepb.Advice{
{
Status: storepb.Advice_ERROR,
- Code: StatementSyntaxErrorCode,
- Title: SyntaxErrorTitle,
+ Code: InternalErrorCode,
+ Title: "Parser conversion error",
Content: err.Error(),
StartPosition: &storepb.Position{
- Line: int32(calculatePostgresErrorLine(statement)),
- },
- },
- }
- }
- var res []ast.Node
- for _, node := range nodes {
- if node != nil {
- res = append(res, node)
- }
- }
- return res, nil
-}
-
-func redshiftSyntaxCheck(statement string) (any, []*storepb.Advice) {
- // Parse using redshift parser to get ANTLR tree
- result, err := redshiftparser.ParseRedshift(statement)
- if err != nil {
- if syntaxErr, ok := err.(*base.SyntaxError); ok {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_ERROR,
- Code: StatementSyntaxErrorCode,
- Title: SyntaxErrorTitle,
- Content: syntaxErr.Message,
- StartPosition: syntaxErr.Position,
+ Line: int32(1),
},
- }
- }
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_ERROR,
- Code: InternalErrorCode,
- Title: "Parse error",
- Content: err.Error(),
- StartPosition: nil,
},
}
}
- if result == nil {
- return nil, nil
- }
- return result.Tree, nil
-}
-
-func calculatePostgresErrorLine(statement string) int {
- singleSQLs, err := base.SplitMultiSQL(storepb.Engine_POSTGRES, statement)
- if err != nil {
- // nolint:nilerr
- return 1
- }
-
- for _, singleSQL := range singleSQLs {
- if _, err := pgrawparser.Parse(pgrawparser.ParseContext{}, singleSQL.Text); err != nil {
- return int(singleSQL.End.GetLine())
- }
- }
-
- return 0
-}
-
-func newTiDBParser() *tidbparser.Parser {
- p := tidbparser.New()
-
- // To support MySQL8 window function syntax.
- // See https://github.com/bytebase/bytebase/issues/175.
- p.EnableWindowFunc(true)
-
- return p
-}
-
-func mysqlSyntaxCheck(statement string) (any, []*storepb.Advice) {
- res, err := mysqlparser.ParseMySQL(statement)
- if err != nil {
- if syntaxErr, ok := err.(*base.SyntaxError); ok {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_ERROR,
- Code: StatementSyntaxErrorCode,
- Title: SyntaxErrorTitle,
- Content: syntaxErr.Message,
- StartPosition: syntaxErr.Position,
- },
- }
- }
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_ERROR,
- Code: InternalErrorCode,
- Title: "Parse error",
- Content: err.Error(),
- StartPosition: nil,
- },
- }
- }
-
- return res, nil
-}
-
-func relocationTiDBErrorLine(errorMessage string, baseLine int) string {
- re := regexp.MustCompile(`line\s+(\d+)`)
- modified := re.ReplaceAllStringFunc(errorMessage, func(match string) string {
- matchSlice := re.FindStringSubmatch(match)
- if len(matchSlice) != 2 {
- return match
- }
- lineStr := matchSlice[1]
- lineNum, err := strconv.Atoi(lineStr)
- if err != nil {
- return match
- }
- newLine := lineNum + baseLine
- return fmt.Sprintf("line %d", newLine)
- })
- return modified
-}
-
-func tidbSyntaxCheck(statement string) (any, []*storepb.Advice) {
- singleSQLs, err := base.SplitMultiSQL(storepb.Engine_TIDB, statement)
- if err != nil {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: InternalErrorCode,
- Title: "Syntax error",
- Content: err.Error(),
- StartPosition: nil,
- },
- }
- }
-
- p := newTiDBParser()
- var returnNodes []tidbast.StmtNode
- var adviceList []*storepb.Advice
- baseLine := 0
- for _, singleSQL := range singleSQLs {
- nodes, _, err := p.Parse(singleSQL.Text, "", "")
- if err != nil {
- return nil, []*storepb.Advice{
- {
- Status: storepb.Advice_WARNING,
- Code: InternalErrorCode,
- Title: "Parse error",
- Content: relocationTiDBErrorLine(err.Error(), baseLine),
- StartPosition: &storepb.Position{
- Line: int32(baseLine),
- },
- },
- }
- }
-
- if len(nodes) != 1 {
- continue
- }
-
- node := nodes[0]
- node.SetText(nil, singleSQL.Text)
- node.SetOriginTextPosition(int(singleSQL.End.GetLine()))
- if n, ok := node.(*tidbast.CreateTableStmt); ok {
- if err := tidbbbparser.SetLineForMySQLCreateTableStmt(n); err != nil {
- return nil, append(adviceList, &storepb.Advice{
- Status: storepb.Advice_ERROR,
- Code: InternalErrorCode,
- Title: "Set line error",
- Content: err.Error(),
- StartPosition: &storepb.Position{
- Line: singleSQL.End.GetLine(),
- },
- })
- }
- }
- returnNodes = append(returnNodes, node)
- baseLine = int(singleSQL.End.GetLine())
+ return []*storepb.Advice{
+ {
+ Status: storepb.Advice_ERROR,
+ Code: InternalErrorCode,
+ Title: SyntaxErrorTitle,
+ Content: err.Error(),
+ StartPosition: nil,
+ },
}
-
- return returnNodes, adviceList
}
diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.go
index a8c438b770..f4cac9e86b 100644
--- a/backend/plugin/parser/base/interface.go
+++ b/backend/plugin/parser/base/interface.go
@@ -29,6 +29,7 @@ var (
spans = make(map[storepb.Engine]GetQuerySpanFunc)
transformDMLToSelect = make(map[storepb.Engine]TransformDMLToSelectFunc)
generateRestoreSQL = make(map[storepb.Engine]GenerateRestoreSQLFunc)
+ parsers = make(map[storepb.Engine]ParseFunc)
)
type ValidateSQLForEditorFunc func(string) (bool, bool, error)
@@ -47,6 +48,11 @@ type TransformDMLToSelectFunc func(ctx context.Context, tCtx TransformContext, s
type GenerateRestoreSQLFunc func(ctx context.Context, rCtx RestoreContext, statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error)
+// ParseFunc is the interface for parsing SQL statements and returning an AST.
+// The return type varies by database engine. See RegisterParser() in each parser package for details.
+// Common types: []ast.Node, antlr.Tree, []*ParseResult, statements.Statements.
+type ParseFunc func(statement string) (any, error)
+
func RegisterQueryValidator(engine storepb.Engine, f ValidateSQLForEditorFunc) {
mux.Lock()
defer mux.Unlock()
@@ -267,6 +273,35 @@ func GenerateRestoreSQL(ctx context.Context, engine storepb.Engine, rCtx Restore
return f(ctx, rCtx, statement, backupItem)
}
+func RegisterParseFunc(engine storepb.Engine, f ParseFunc) {
+ mux.Lock()
+ defer mux.Unlock()
+ if _, dup := parsers[engine]; dup {
+ panic(fmt.Sprintf("Register called twice %s", engine))
+ }
+ parsers[engine] = f
+}
+
+// Parse parses the SQL statement and returns the AST.
+// The return type (any) varies by database engine:
+// - TiDB: []ast.StmtNode (github.com/pingcap/tidb/pkg/parser/ast)
+// - MySQL, MariaDB, OceanBase: []*ParseResult (github.com/bytebase/bytebase/backend/plugin/parser/mysql)
+// - PostgreSQL: []ast.Node (github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast)
+// - CockroachDB: statements.Statements (github.com/cockroachdb/cockroachdb-parser/pkg/sql/parser/statements)
+// - Redshift: antlr.Tree
+// - Oracle: antlr.Tree
+// - Snowflake: antlr.Tree
+// - MSSQL: antlr.Tree
+// - DynamoDB (PartiQL): antlr.Tree
+// - Doris: *ParseResult (github.com/bytebase/bytebase/backend/plugin/parser/doris)
+func Parse(engine storepb.Engine, statement string) (any, error) {
+ f, ok := parsers[engine]
+ if !ok {
+ return nil, errors.Errorf("engine %s is not supported", engine)
+ }
+ return f(statement)
+}
+
type ChangeSummary struct {
ChangedResources *model.ChangedResources
SampleDMLS []string
diff --git a/backend/plugin/parser/cockroachdb/cockroachdb.go b/backend/plugin/parser/cockroachdb/cockroachdb.go
index 0a6fe967d3..257efbd486 100644
--- a/backend/plugin/parser/cockroachdb/cockroachdb.go
+++ b/backend/plugin/parser/cockroachdb/cockroachdb.go
@@ -6,9 +6,28 @@ import (
crrawparser "github.com/cockroachdb/cockroachdb-parser/pkg/sql/parser"
"github.com/cockroachdb/cockroachdb-parser/pkg/sql/parser/statements"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/utils"
)
+func init() {
+ base.RegisterParseFunc(storepb.Engine_COCKROACHDB, parseCockroachDBForRegistry)
+}
+
+// parseCockroachDBForRegistry is the ParseFunc for CockroachDB.
+// Returns statements.Statements (github.com/cockroachdb/cockroachdb-parser/pkg/sql/parser/statements) on success.
+func parseCockroachDBForRegistry(statement string) (any, error) {
+ result, err := ParseCockroachDBSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+ if result == nil {
+ return nil, nil
+ }
+ return result.Stmts, nil
+}
+
type ParseResult struct {
Stmts statements.Statements
}
diff --git a/backend/plugin/parser/doris/doris.go b/backend/plugin/parser/doris/doris.go
index 2d6e43a2e0..249c204c51 100644
--- a/backend/plugin/parser/doris/doris.go
+++ b/backend/plugin/parser/doris/doris.go
@@ -4,9 +4,24 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/doris-parser"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
)
+func init() {
+ base.RegisterParseFunc(storepb.Engine_DORIS, parseDorisForRegistry)
+}
+
+// parseDorisForRegistry is the ParseFunc for Doris.
+// Returns *ParseResult on success.
+func parseDorisForRegistry(statement string) (any, error) {
+ result, err := ParseDorisSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+ return result, nil
+}
+
// ParseResult is the result of parsing a MySQL statement.
type ParseResult struct {
Tree antlr.Tree
diff --git a/backend/plugin/parser/mysql/mysql.go b/backend/plugin/parser/mysql/mysql.go
index bb84552009..b10d123a53 100644
--- a/backend/plugin/parser/mysql/mysql.go
+++ b/backend/plugin/parser/mysql/mysql.go
@@ -11,10 +11,23 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/mysql-parser"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/plugin/parser/tokenizer"
)
+func init() {
+ base.RegisterParseFunc(storepb.Engine_MYSQL, parseMySQLForRegistry)
+ base.RegisterParseFunc(storepb.Engine_MARIADB, parseMySQLForRegistry)
+ base.RegisterParseFunc(storepb.Engine_OCEANBASE, parseMySQLForRegistry)
+}
+
+// parseMySQLForRegistry is the ParseFunc for MySQL, MariaDB, and OceanBase.
+// Returns []*ParseResult on success.
+func parseMySQLForRegistry(statement string) (any, error) {
+ return ParseMySQL(statement)
+}
+
// ParseResult is the result of parsing a MySQL statement.
type ParseResult struct {
Tree antlr.Tree
diff --git a/backend/plugin/parser/partiql/partiql.go b/backend/plugin/parser/partiql/partiql.go
index b04087ab3d..7225c3da66 100644
--- a/backend/plugin/parser/partiql/partiql.go
+++ b/backend/plugin/parser/partiql/partiql.go
@@ -7,10 +7,28 @@ import (
parser "github.com/bytebase/partiql-parser"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/utils"
)
+func init() {
+ base.RegisterParseFunc(storepb.Engine_DYNAMODB, parsePartiQLForRegistry)
+}
+
+// parsePartiQLForRegistry is the ParseFunc for PartiQL.
+// Returns antlr.Tree on success.
+func parsePartiQLForRegistry(statement string) (any, error) {
+ result, err := ParsePartiQL(statement)
+ if err != nil {
+ return nil, err
+ }
+ if result == nil {
+ return nil, nil
+ }
+ return result.Tree, nil
+}
+
type ParseResult struct {
Tree antlr.Tree
Tokens *antlr.CommonTokenStream
diff --git a/backend/plugin/parser/pg/legacy/parser.go b/backend/plugin/parser/pg/legacy/parser.go
index ee83934f7b..b12afdef47 100644
--- a/backend/plugin/parser/pg/legacy/parser.go
+++ b/backend/plugin/parser/pg/legacy/parser.go
@@ -7,12 +7,61 @@ import (
pgquery "github.com/pganalyze/pg_query_go/v6"
"github.com/pkg/errors"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/plugin/parser/tokenizer"
"github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"
)
+func init() {
+ base.RegisterParseFunc(storepb.Engine_POSTGRES, parsePostgresForRegistry)
+}
+
+// parsePostgresForRegistry is the ParseFunc for PostgreSQL.
+// Returns []ast.Node (github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast) on success.
+func parsePostgresForRegistry(statement string) (any, error) {
+ nodes, err := Parse(ParseContext{}, statement)
+ if err != nil {
+ // For ConvertError, return as-is (will be handled by convertErrorToAdvice in sheet.go)
+ if _, ok := err.(*ConvertError); ok {
+ return nil, err
+ }
+ // For other errors, wrap in base.SyntaxError with proper line number
+ line := calculatePostgresErrorLine(statement)
+ return nil, &base.SyntaxError{
+ Position: &storepb.Position{
+ Line: int32(line),
+ },
+ Message: err.Error(),
+ }
+ }
+ // Filter out nil nodes
+ var res []ast.Node
+ for _, node := range nodes {
+ if node != nil {
+ res = append(res, node)
+ }
+ }
+ return res, nil
+}
+
+// calculatePostgresErrorLine calculates the line number where the PostgreSQL error occurred.
+func calculatePostgresErrorLine(statement string) int {
+ singleSQLs, err := base.SplitMultiSQL(storepb.Engine_POSTGRES, statement)
+ if err != nil {
+ return 1
+ }
+
+ for _, singleSQL := range singleSQLs {
+ if _, err := Parse(ParseContext{}, singleSQL.Text); err != nil {
+ return int(singleSQL.End.GetLine())
+ }
+ }
+
+ return 1
+}
+
const (
operatorLike string = "~~"
operatorNotLike string = "!~~"
diff --git a/backend/plugin/parser/plsql/plsql.go b/backend/plugin/parser/plsql/plsql.go
index b14a66d644..8a1e186cdd 100644
--- a/backend/plugin/parser/plsql/plsql.go
+++ b/backend/plugin/parser/plsql/plsql.go
@@ -10,9 +10,24 @@ import (
parser "github.com/bytebase/plsql-parser"
"github.com/pkg/errors"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
)
+func init() {
+ base.RegisterParseFunc(storepb.Engine_ORACLE, parsePLSQLForRegistry)
+}
+
+// parsePLSQLForRegistry is the ParseFunc for PL/SQL.
+// Returns antlr.Tree on success.
+func parsePLSQLForRegistry(statement string) (any, error) {
+ tree, _, err := ParsePLSQL(statement + ";")
+ if err != nil {
+ return nil, err
+ }
+ return tree, nil
+}
+
type Version struct {
First int
Second int
diff --git a/backend/plugin/parser/redshift/redshift.go b/backend/plugin/parser/redshift/redshift.go
index 52e2b6ee5f..b16bcea0cb 100644
--- a/backend/plugin/parser/redshift/redshift.go
+++ b/backend/plugin/parser/redshift/redshift.go
@@ -6,10 +6,28 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/parser/redshift"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/utils"
)
+func init() {
+ base.RegisterParseFunc(storepb.Engine_REDSHIFT, parseRedshiftForRegistry)
+}
+
+// parseRedshiftForRegistry is the ParseFunc for Redshift.
+// Returns antlr.Tree on success.
+func parseRedshiftForRegistry(statement string) (any, error) {
+ result, err := ParseRedshift(statement)
+ if err != nil {
+ return nil, err
+ }
+ if result == nil {
+ return nil, nil
+ }
+ return result.Tree, nil
+}
+
// ParseResult is the result of parsing a Redshift statement.
type ParseResult struct {
Tree antlr.Tree
diff --git a/backend/plugin/parser/snowflake/snowflake.go b/backend/plugin/parser/snowflake/snowflake.go
index 1b1fcf935d..de687fd61d 100644
--- a/backend/plugin/parser/snowflake/snowflake.go
+++ b/backend/plugin/parser/snowflake/snowflake.go
@@ -7,10 +7,28 @@ import (
"github.com/antlr4-go/antlr/v4"
parser "github.com/bytebase/snowsql-parser"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/utils"
)
+func init() {
+ base.RegisterParseFunc(storepb.Engine_SNOWFLAKE, parseSnowflakeForRegistry)
+}
+
+// parseSnowflakeForRegistry is the ParseFunc for Snowflake.
+// Returns antlr.Tree on success.
+func parseSnowflakeForRegistry(statement string) (any, error) {
+ result, err := ParseSnowSQL(statement + ";")
+ if err != nil {
+ return nil, err
+ }
+ if result == nil {
+ return nil, nil
+ }
+ return result.Tree, nil
+}
+
type ParseResult struct {
Tree antlr.Tree
Tokens *antlr.CommonTokenStream
diff --git a/backend/plugin/parser/tidb/tidb.go b/backend/plugin/parser/tidb/tidb.go
index d596ef53b8..7620ee1130 100644
--- a/backend/plugin/parser/tidb/tidb.go
+++ b/backend/plugin/parser/tidb/tidb.go
@@ -19,10 +19,60 @@ import (
parser "github.com/bytebase/tidb-parser"
"github.com/bytebase/bytebase/backend/common"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
"github.com/bytebase/bytebase/backend/plugin/parser/tokenizer"
)
+func init() {
+ base.RegisterParseFunc(storepb.Engine_TIDB, ParseTiDBForSyntaxCheck)
+}
+
+// ParseTiDBForSyntaxCheck parses TiDB SQL for syntax checking purposes.
+func ParseTiDBForSyntaxCheck(statement string) (any, error) {
+ singleSQLs, err := base.SplitMultiSQL(storepb.Engine_TIDB, statement)
+ if err != nil {
+ return nil, err
+ }
+
+ p := newTiDBParser()
+ var returnNodes []ast.StmtNode
+ baseLine := 0
+ for _, singleSQL := range singleSQLs {
+ nodes, _, err := p.Parse(singleSQL.Text, "", "")
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to parse statement at line %d", baseLine)
+ }
+
+ if len(nodes) != 1 {
+ continue
+ }
+
+ node := nodes[0]
+ node.SetText(nil, singleSQL.Text)
+ node.SetOriginTextPosition(int(singleSQL.End.GetLine()))
+ if n, ok := node.(*ast.CreateTableStmt); ok {
+ if err := SetLineForMySQLCreateTableStmt(n); err != nil {
+ return nil, errors.Wrapf(err, "failed to set line for create table statement at line %d", singleSQL.End.GetLine())
+ }
+ }
+ returnNodes = append(returnNodes, node)
+ baseLine = int(singleSQL.End.GetLine())
+ }
+
+ return returnNodes, nil
+}
+
+func newTiDBParser() *tidbparser.Parser {
+ p := tidbparser.New()
+
+ // To support MySQL8 window function syntax.
+ // See https://github.com/bytebase/bytebase/issues/175.
+ p.EnableWindowFunc(true)
+
+ return p
+}
+
// ParseTiDB parses the given SQL statement and returns the AST.
func ParseTiDB(sql string, charset string, collation string) ([]ast.StmtNode, error) {
p := tidbparser.New()
diff --git a/backend/plugin/parser/tsql/tsql.go b/backend/plugin/parser/tsql/tsql.go
index f4d090b558..1d7541c8cb 100644
--- a/backend/plugin/parser/tsql/tsql.go
+++ b/backend/plugin/parser/tsql/tsql.go
@@ -9,9 +9,27 @@ import (
parser "github.com/bytebase/tsql-parser"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
)
+func init() {
+ base.RegisterParseFunc(storepb.Engine_MSSQL, parseTSQLForRegistry)
+}
+
+// parseTSQLForRegistry is the ParseFunc for T-SQL.
+// Returns antlr.Tree on success.
+func parseTSQLForRegistry(statement string) (any, error) {
+ result, err := ParseTSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+ if result == nil {
+ return nil, nil
+ }
+ return result.Tree, nil
+}
+
type ParseResult struct {
Tree antlr.Tree
Tokens *antlr.CommonTokenStream