Skip to content

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

refactor(parser): consolidate SingleSQL into Statement and ParsedStatement types (#18464)

h3n4l17f461015bc9
diff --git a/backend/component/sheet/sheet.go b/backend/component/sheet/sheet.go
index 5fda5791ae..d6f034d82a 100644
--- a/backend/component/sheet/sheet.go
+++ b/backend/component/sheet/sheet.go
@@ -186,17 +186,17 @@ func getSheetCommandsForMSSQL(statement string) []*storepb.Range {
return sheetCommands
}
-// StatementResult holds the cached parsing results with the unified Statement type.
+// StatementResult holds the cached parsing results with the unified ParsedStatement type.
type StatementResult struct {
sync.Mutex
- statements []base.Statement
+ statements []base.ParsedStatement
advices []*storepb.Advice
}
// GetStatementsForChecks gets the unified Statements (with both text and AST) with caching.
-// This is the new unified API that returns complete Statement objects.
+// This is the new unified API that returns complete ParsedStatement objects.
// Use this for new code that needs both text and AST information.
-func (sm *Manager) GetStatementsForChecks(dbType storepb.Engine, statement string) ([]base.Statement, []*storepb.Advice) {
+func (sm *Manager) GetStatementsForChecks(dbType storepb.Engine, statement string) ([]base.ParsedStatement, []*storepb.Advice) {
var result *StatementResult
h := xxh3.HashString(statement)
key := astHashKey{hash: h, engine: dbType}
diff --git a/backend/plugin/db/clickhouse/clickhouse.go b/backend/plugin/db/clickhouse/clickhouse.go
index 06bb424860..09cec5d166 100644
--- a/backend/plugin/db/clickhouse/clickhouse.go
+++ b/backend/plugin/db/clickhouse/clickhouse.go
@@ -137,7 +137,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
if err != nil {
return 0, err
}
- singleSQLs = base.FilterEmptySQL(singleSQLs)
+ singleSQLs = base.FilterEmptyStatements(singleSQLs)
if len(singleSQLs) == 0 {
return 0, nil
}
@@ -149,7 +149,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
return d.executeInTransactionMode(ctx, singleSQLs, opts)
}
-func (d *Driver) executeInTransactionMode(ctx context.Context, singleSQLs []base.SingleSQL, opts db.ExecuteOptions) (int64, error) {
+func (d *Driver) executeInTransactionMode(ctx context.Context, singleSQLs []base.Statement, opts db.ExecuteOptions) (int64, error) {
tx, err := d.db.BeginTx(ctx, nil)
if err != nil {
return 0, err
@@ -202,7 +202,7 @@ func (d *Driver) executeInTransactionMode(ctx context.Context, singleSQLs []base
return totalRowsAffected, nil
}
-func (d *Driver) executeInAutoCommitMode(ctx context.Context, singleSQLs []base.SingleSQL, opts db.ExecuteOptions) (int64, error) {
+func (d *Driver) executeInAutoCommitMode(ctx context.Context, singleSQLs []base.Statement, opts db.ExecuteOptions) (int64, error) {
totalRowsAffected := int64(0)
for i, singleSQL := range singleSQLs {
opts.LogCommandExecute([]int32{int32(i)}, singleSQL.Text)
diff --git a/backend/plugin/db/clickhouse/query.go b/backend/plugin/db/clickhouse/query.go
index b213d450a6..d9e7d12b19 100644
--- a/backend/plugin/db/clickhouse/query.go
+++ b/backend/plugin/db/clickhouse/query.go
@@ -33,7 +33,7 @@ func (*Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string,
if err != nil {
return nil, err
}
- singleSQLs = base.FilterEmptySQL(singleSQLs)
+ singleSQLs = base.FilterEmptyStatements(singleSQLs)
if len(singleSQLs) == 0 {
return nil, nil
}
diff --git a/backend/plugin/db/cockroachdb/cockroachdb.go b/backend/plugin/db/cockroachdb/cockroachdb.go
index 7c2a4a8300..76c509eff2 100644
--- a/backend/plugin/db/cockroachdb/cockroachdb.go
+++ b/backend/plugin/db/cockroachdb/cockroachdb.go
@@ -264,7 +264,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
return 0, err
}
- var commands []base.SingleSQL
+ var commands []base.Statement
var originalIndex []int32
var nonTransactionAndSetRoleStmts []string
var nonTransactionAndSetRoleStmtsIndex []int32
@@ -275,7 +275,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
return 0, err
}
for i, singleSQL := range singleSQLs {
- commands = append(commands, base.SingleSQL{Text: singleSQL})
+ commands = append(commands, base.Statement{Text: singleSQL})
originalIndex = append(originalIndex, int32(i))
}
@@ -287,7 +287,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
isPlsql = true
}
- var tmpCommands []base.SingleSQL
+ var tmpCommands []base.Statement
var tmpOriginalIndex []int32
for i, command := range commands {
switch {
@@ -325,7 +325,7 @@ func (d *Driver) executeInTransactionMode(
ctx context.Context,
owner string,
statement string,
- commands []base.SingleSQL,
+ commands []base.Statement,
originalIndex []int32,
nonTransactionAndSetRoleStmts []string,
nonTransactionAndSetRoleStmtsIndex []int32,
@@ -472,7 +472,7 @@ func (d *Driver) executeInAutoCommitMode(
ctx context.Context,
owner string,
statement string,
- commands []base.SingleSQL,
+ commands []base.Statement,
originalIndex []int32,
nonTransactionAndSetRoleStmts []string,
nonTransactionAndSetRoleStmtsIndex []int32,
diff --git a/backend/plugin/db/databricks/databricks.go b/backend/plugin/db/databricks/databricks.go
index 05cf57ed8c..d361141136 100644
--- a/backend/plugin/db/databricks/databricks.go
+++ b/backend/plugin/db/databricks/databricks.go
@@ -88,7 +88,7 @@ func (d *Driver) QueryConn(ctx context.Context, _ *sql.Conn, statement string, _
for _, stmt := range stmts {
result := &v1pb.QueryResult{}
startTime := time.Now()
- dataArr, colInfo, err := d.execSingleSQLSync(ctx, stmt.Text)
+ dataArr, colInfo, err := d.execStatementSync(ctx, stmt.Text)
if err != nil {
return nil, err
}
@@ -158,7 +158,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, _ db.ExecuteOpti
}
// Execute SQL statement synchronously and return row data or error.
-func (d *Driver) execSingleSQLSync(ctx context.Context, statement string) ([][]string, []dbsql.ColumnInfo, error) {
+func (d *Driver) execStatementSync(ctx context.Context, statement string) ([][]string, []dbsql.ColumnInfo, error) {
resp, err := d.Client.StatementExecution.ExecuteAndWait(ctx, dbsql.ExecuteStatementRequest{
Statement: statement,
WarehouseId: d.WarehouseID,
diff --git a/backend/plugin/db/databricks/dump.go b/backend/plugin/db/databricks/dump.go
index a00deb1a9b..f4ef7ed9ef 100644
--- a/backend/plugin/db/databricks/dump.go
+++ b/backend/plugin/db/databricks/dump.go
@@ -129,7 +129,7 @@ func (d *Driver) Dump(ctx context.Context, writer io.Writer, _ *storepb.Database
}
func (d *Driver) showCreateTable(ctx context.Context, qualifiedTblName string) (string, error) {
- rows, colInfo, err := d.execSingleSQLSync(ctx, fmt.Sprintf("SHOW CREATE TABLE %s", qualifiedTblName))
+ rows, colInfo, err := d.execStatementSync(ctx, fmt.Sprintf("SHOW CREATE TABLE %s", qualifiedTblName))
if err != nil {
return "", err
}
@@ -170,7 +170,7 @@ func (d *Driver) descTbl(ctx context.Context, tblName string) (*tableAdditionalI
tblAddInfo := &tableAdditionalInfo{
tblProps: make(map[string]string),
}
- rows, _, err := d.execSingleSQLSync(ctx, fmt.Sprintf("DESC FORMATTED %s", tblName))
+ rows, _, err := d.execStatementSync(ctx, fmt.Sprintf("DESC FORMATTED %s", tblName))
if err != nil {
return nil, err
}
diff --git a/backend/plugin/db/databricks/sync.go b/backend/plugin/db/databricks/sync.go
index cac3d107bd..a576970642 100644
--- a/backend/plugin/db/databricks/sync.go
+++ b/backend/plugin/db/databricks/sync.go
@@ -54,7 +54,7 @@ func (d *Driver) SyncInstance(ctx context.Context) (*db.InstanceMetadata, error)
instanceMetadata := &db.InstanceMetadata{}
// fetch version.
- versionData, _, err := d.execSingleSQLSync(ctx, "SELECT VERSION()")
+ versionData, _, err := d.execStatementSync(ctx, "SELECT VERSION()")
if err != nil {
return nil, err
}
diff --git a/backend/plugin/db/dynamodb/dynamodb.go b/backend/plugin/db/dynamodb/dynamodb.go
index b83c8883ba..89e4c9c696 100644
--- a/backend/plugin/db/dynamodb/dynamodb.go
+++ b/backend/plugin/db/dynamodb/dynamodb.go
@@ -101,7 +101,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
if err != nil {
return 0, errors.Wrapf(err, "failed to split multi statement")
}
- nonEmptyStatements, idxMap := base.FilterEmptySQLWithIndexes(statements)
+ nonEmptyStatements, idxMap := base.FilterEmptyStatementsWithIndexes(statements)
for currentIndex, statement := range nonEmptyStatements {
opts.LogCommandExecute([]int32{int32(idxMap[currentIndex])}, statement.Text)
@@ -137,7 +137,7 @@ func (d *Driver) QueryConn(ctx context.Context, _ *sql.Conn, statement string, q
if err != nil {
return nil, errors.Wrapf(err, "failed to split multi statement")
}
- singleSQLs = base.FilterEmptySQL(singleSQLs)
+ singleSQLs = base.FilterEmptyStatements(singleSQLs)
if len(singleSQLs) == 0 {
return nil, nil
}
diff --git a/backend/plugin/db/mssql/mssql.go b/backend/plugin/db/mssql/mssql.go
index 38d75ceb9c..21ac689ad0 100644
--- a/backend/plugin/db/mssql/mssql.go
+++ b/backend/plugin/db/mssql/mssql.go
@@ -419,7 +419,7 @@ func (*Driver) queryBatch(ctx context.Context, conn *sql.Conn, batch string, que
if err != nil {
return nil, err
}
- singleSQLs = base.FilterEmptySQL(singleSQLs)
+ singleSQLs = base.FilterEmptyStatements(singleSQLs)
if len(singleSQLs) == 0 {
return nil, nil
}
diff --git a/backend/plugin/db/mysql/mysql.go b/backend/plugin/db/mysql/mysql.go
index 5850c94b02..2561814312 100644
--- a/backend/plugin/db/mysql/mysql.go
+++ b/backend/plugin/db/mysql/mysql.go
@@ -336,7 +336,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
slog.Debug("connectionID", slog.String("connectionID", connectionID))
var totalCommands int
- var commands []base.SingleSQL
+ var commands []base.Statement
var originalIndex []int32
oneshot := true
if len(statement) <= common.MaxSheetCheckSize {
@@ -344,7 +344,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
if err != nil {
return 0, errors.Wrapf(err, "failed to split sql")
}
- singleSQLs, originalIndex = base.FilterEmptySQLWithIndexes(singleSQLs)
+ singleSQLs, originalIndex = base.FilterEmptyStatementsWithIndexes(singleSQLs)
if len(singleSQLs) == 0 {
return 0, nil
}
@@ -355,7 +355,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
}
}
if oneshot {
- commands = []base.SingleSQL{
+ commands = []base.Statement{
{
Text: statement,
},
@@ -384,7 +384,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
}
// executeInTransactionMode executes statements within a single transaction
-func (d *Driver) executeInTransactionMode(ctx context.Context, conn *sql.Conn, commands []base.SingleSQL, originalIndex []int32, opts db.ExecuteOptions, connectionID string, isolationLevel common.IsolationLevel) (int64, error) {
+func (d *Driver) executeInTransactionMode(ctx context.Context, conn *sql.Conn, commands []base.Statement, originalIndex []int32, opts db.ExecuteOptions, connectionID string, isolationLevel common.IsolationLevel) (int64, error) {
var totalRowsAffected int64
if err := conn.Raw(func(driverConn any) error {
@@ -471,7 +471,7 @@ func (d *Driver) executeInTransactionMode(ctx context.Context, conn *sql.Conn, c
}
// executeInAutoCommitMode executes statements sequentially in auto-commit mode
-func (d *Driver) executeInAutoCommitMode(ctx context.Context, conn *sql.Conn, commands []base.SingleSQL, originalIndex []int32, opts db.ExecuteOptions, connectionID string) (int64, error) {
+func (d *Driver) executeInAutoCommitMode(ctx context.Context, conn *sql.Conn, commands []base.Statement, originalIndex []int32, opts db.ExecuteOptions, connectionID string) (int64, error) {
var totalRowsAffected int64
if err := conn.Raw(func(driverConn any) error {
@@ -528,7 +528,7 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string
if err != nil {
return nil, err
}
- singleSQLs = base.FilterEmptySQL(singleSQLs)
+ singleSQLs = base.FilterEmptyStatements(singleSQLs)
if len(singleSQLs) == 0 {
return nil, nil
}
diff --git a/backend/plugin/db/oracle/oracle.go b/backend/plugin/db/oracle/oracle.go
index 66ca8f3e9b..989dd11ff7 100644
--- a/backend/plugin/db/oracle/oracle.go
+++ b/backend/plugin/db/oracle/oracle.go
@@ -117,7 +117,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
transactionMode = common.GetDefaultTransactionMode()
}
- var commands []base.SingleSQL
+ var commands []base.Statement
var originalIndex []int32
if len(statement) <= common.MaxSheetCheckSize {
// Use Oracle sql parser.
@@ -125,13 +125,13 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
if err != nil {
return 0, errors.Wrapf(err, "failed to split sql")
}
- singleSQLs, originalIndex = base.FilterEmptySQLWithIndexes(singleSQLs)
+ singleSQLs, originalIndex = base.FilterEmptyStatementsWithIndexes(singleSQLs)
if len(singleSQLs) == 0 {
return 0, nil
}
commands = singleSQLs
} else {
- commands = []base.SingleSQL{
+ commands = []base.Statement{
{
Text: statement,
},
@@ -153,7 +153,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
}
// executeInTransactionMode executes statements within a single transaction
-func (*Driver) executeInTransactionMode(ctx context.Context, conn *sql.Conn, commands []base.SingleSQL, originalIndex []int32, opts db.ExecuteOptions) (int64, error) {
+func (*Driver) executeInTransactionMode(ctx context.Context, conn *sql.Conn, commands []base.Statement, originalIndex []int32, opts db.ExecuteOptions) (int64, error) {
tx, err := conn.BeginTx(ctx, nil)
if err != nil {
opts.LogTransactionControl(storepb.TaskRunLog_TransactionControl_BEGIN, err.Error())
@@ -208,7 +208,7 @@ func (*Driver) executeInTransactionMode(ctx context.Context, conn *sql.Conn, com
}
// executeInAutoCommitMode executes statements sequentially in auto-commit mode
-func (*Driver) executeInAutoCommitMode(ctx context.Context, conn *sql.Conn, commands []base.SingleSQL, originalIndex []int32, opts db.ExecuteOptions) (int64, error) {
+func (*Driver) executeInAutoCommitMode(ctx context.Context, conn *sql.Conn, commands []base.Statement, originalIndex []int32, opts db.ExecuteOptions) (int64, error) {
totalRowsAffected := int64(0)
for i, command := range commands {
indexes := []int32{originalIndex[i]}
@@ -243,7 +243,7 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string
if err != nil {
return nil, err
}
- singleSQLs = base.FilterEmptySQL(singleSQLs)
+ singleSQLs = base.FilterEmptyStatements(singleSQLs)
if len(singleSQLs) == 0 {
return nil, nil
}
diff --git a/backend/plugin/db/pg/pg.go b/backend/plugin/db/pg/pg.go
index 0432d8ea82..7ca9783f2f 100644
--- a/backend/plugin/db/pg/pg.go
+++ b/backend/plugin/db/pg/pg.go
@@ -379,7 +379,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
return 0, err
}
- var commands []base.SingleSQL
+ var commands []base.Statement
var originalIndex []int32
var nonTransactionAndSetRoleStmts []string
var nonTransactionAndSetRoleStmtsIndex []int32
@@ -391,7 +391,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
if err != nil {
return 0, err
}
- commands, originalIndex = base.FilterEmptySQLWithIndexes(singleSQLs)
+ commands, originalIndex = base.FilterEmptyStatementsWithIndexes(singleSQLs)
// If the statement is a single statement and is a PL/pgSQL block,
// we should execute it as a single statement without transaction.
@@ -401,7 +401,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
isPlsql = true
}
- var tmpCommands []base.SingleSQL
+ var tmpCommands []base.Statement
var tmpOriginalIndex []int32
for i, command := range commands {
switch {
@@ -484,7 +484,7 @@ func (d *Driver) executeInTransactionMode(
ctx context.Context,
owner string,
statement string,
- commands []base.SingleSQL,
+ commands []base.Statement,
originalIndex []int32,
nonTransactionAndSetRoleStmts []string,
nonTransactionAndSetRoleStmtsIndex []int32,
@@ -630,7 +630,7 @@ func (d *Driver) executeInAutoCommitMode(
ctx context.Context,
owner string,
statement string,
- commands []base.SingleSQL,
+ commands []base.Statement,
originalIndex []int32,
nonTransactionAndSetRoleStmts []string,
nonTransactionAndSetRoleStmtsIndex []int32,
@@ -810,7 +810,7 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string
if err != nil {
return nil, err
}
- singleSQLs = base.FilterEmptySQL(singleSQLs)
+ singleSQLs = base.FilterEmptyStatements(singleSQLs)
if len(singleSQLs) == 0 {
return nil, nil
}
diff --git a/backend/plugin/db/redshift/redshift.go b/backend/plugin/db/redshift/redshift.go
index e6fe9596d9..c6398e53d2 100644
--- a/backend/plugin/db/redshift/redshift.go
+++ b/backend/plugin/db/redshift/redshift.go
@@ -176,20 +176,20 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
transactionMode = common.GetDefaultTransactionMode()
}
- var commands []base.SingleSQL
+ var commands []base.Statement
oneshot := true
if len(statement) <= common.MaxSheetCheckSize {
singleSQLs, err := pgparser.SplitSQL(statement)
if err != nil {
return 0, err
}
- commands = base.FilterEmptySQL(singleSQLs)
+ commands = base.FilterEmptyStatements(singleSQLs)
if len(commands) <= common.MaximumCommands {
oneshot = false
}
}
if oneshot {
- commands = []base.SingleSQL{
+ commands = []base.Statement{
{
Text: statement,
},
@@ -228,7 +228,7 @@ func (d *Driver) createDatabaseExecute(ctx context.Context, statement string) er
}
// executeInTransactionMode executes statements within a single transaction
-func (d *Driver) executeInTransactionMode(ctx context.Context, commands []base.SingleSQL, opts db.ExecuteOptions) (int64, error) {
+func (d *Driver) executeInTransactionMode(ctx context.Context, commands []base.Statement, opts db.ExecuteOptions) (int64, error) {
totalRowsAffected := int64(0)
if len(commands) == 0 {
return 0, nil
@@ -292,7 +292,7 @@ func (d *Driver) executeInTransactionMode(ctx context.Context, commands []base.S
}
// executeInAutoCommitMode executes statements sequentially in auto-commit mode
-func (d *Driver) executeInAutoCommitMode(ctx context.Context, commands []base.SingleSQL, opts db.ExecuteOptions) (int64, error) {
+func (d *Driver) executeInAutoCommitMode(ctx context.Context, commands []base.Statement, opts db.ExecuteOptions) (int64, error) {
totalRowsAffected := int64(0)
for i, command := range commands {
@@ -373,7 +373,7 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string
if err != nil {
return nil, err
}
- singleSQLs = base.FilterEmptySQL(singleSQLs)
+ singleSQLs = base.FilterEmptyStatements(singleSQLs)
if len(singleSQLs) == 0 {
return nil, nil
}
diff --git a/backend/plugin/db/spanner/spanner.go b/backend/plugin/db/spanner/spanner.go
index 265c3606aa..555802fccb 100644
--- a/backend/plugin/db/spanner/spanner.go
+++ b/backend/plugin/db/spanner/spanner.go
@@ -338,7 +338,7 @@ func (d *Driver) QueryConn(ctx context.Context, _ *sql.Conn, statement string, q
if queryContext.Limit > 0 {
limitedStatement = getStatementWithResultLimit(statement, queryContext.Limit)
}
- return d.querySingleSQL(ctx, limitedStatement, queryContext)
+ return d.queryStatement(ctx, limitedStatement, queryContext)
}
if util.IsDDL(statement) {
op, err := d.dbClient.UpdateDatabaseDdl(ctx, &databasepb.UpdateDatabaseDdlRequest{
@@ -385,7 +385,7 @@ func (d *Driver) QueryConn(ctx context.Context, _ *sql.Conn, statement string, q
return results, nil
}
-func (d *Driver) querySingleSQL(ctx context.Context, statement string, queryContext db.QueryContext) (*v1pb.QueryResult, error) {
+func (d *Driver) queryStatement(ctx context.Context, statement string, queryContext db.QueryContext) (*v1pb.QueryResult, error) {
iter := d.client.Single().Query(ctx, spanner.NewStatement(statement))
defer iter.Stop()
diff --git a/backend/plugin/db/starrocks/starrocks.go b/backend/plugin/db/starrocks/starrocks.go
index f055eb9875..3540189746 100644
--- a/backend/plugin/db/starrocks/starrocks.go
+++ b/backend/plugin/db/starrocks/starrocks.go
@@ -277,7 +277,7 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string
if err != nil {
return nil, err
}
- singleSQLs = base.FilterEmptySQL(singleSQLs)
+ singleSQLs = base.FilterEmptyStatements(singleSQLs)
if len(singleSQLs) == 0 {
return nil, nil
}
diff --git a/backend/plugin/db/tidb/tidb.go b/backend/plugin/db/tidb/tidb.go
index 16598a382b..70e6add143 100644
--- a/backend/plugin/db/tidb/tidb.go
+++ b/backend/plugin/db/tidb/tidb.go
@@ -184,9 +184,9 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
slog.Debug("connectionID", slog.String("connectionID", connectionID))
var remainingSQLsIndex, nonTransactionStmtsIndex []int
- var nonTransactionStmts []base.SingleSQL
+ var nonTransactionStmts []base.Statement
var totalCommands int
- var commands []base.SingleSQL
+ var commands []base.Statement
var originalIndex []int32
oneshot := true
if len(statement) <= common.MaxSheetCheckSize {
@@ -194,7 +194,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
if err != nil {
return 0, errors.Wrapf(err, "failed to split sql")
}
- singleSQLs, originalIndex = base.FilterEmptySQLWithIndexes(singleSQLs)
+ singleSQLs, originalIndex = base.FilterEmptyStatementsWithIndexes(singleSQLs)
if len(singleSQLs) == 0 {
return 0, nil
}
@@ -203,7 +203,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
oneshot = false
// Find non-transactional statements.
// TiDB cannot run create table and create index in a single transaction.
- var remainingSQLs []base.SingleSQL
+ var remainingSQLs []base.Statement
for i, singleSQL := range singleSQLs {
if isNonTransactionStatement(singleSQL.Text) {
nonTransactionStmts = append(nonTransactionStmts, singleSQL)
@@ -217,7 +217,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
}
}
if oneshot {
- commands = []base.SingleSQL{
+ commands = []base.Statement{
{
Text: statement,
},
@@ -234,7 +234,7 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
}
// executeInTransactionMode executes statements within a single transaction
-func (d *Driver) executeInTransactionMode(ctx context.Context, conn *sql.Conn, commands []base.SingleSQL, nonTransactionStmts []base.SingleSQL, remainingSQLsIndex, nonTransactionStmtsIndex []int, originalIndex []int32, opts db.ExecuteOptions, connectionID string) (int64, error) {
+func (d *Driver) executeInTransactionMode(ctx context.Context, conn *sql.Conn, commands []base.Statement, nonTransactionStmts []base.Statement, remainingSQLsIndex, nonTransactionStmtsIndex []int, originalIndex []int32, opts db.ExecuteOptions, connectionID string) (int64, error) {
var totalRowsAffected int64
if err := conn.Raw(func(driverConn any) error {
@@ -324,11 +324,11 @@ func (d *Driver) executeInTransactionMode(ctx context.Context, conn *sql.Conn, c
}
// executeInAutoCommitMode executes statements sequentially in auto-commit mode
-func (d *Driver) executeInAutoCommitMode(ctx context.Context, conn *sql.Conn, commands []base.SingleSQL, nonTransactionStmts []base.SingleSQL, remainingSQLsIndex, nonTransactionStmtsIndex []int, originalIndex []int32, opts db.ExecuteOptions, connectionID string) (int64, error) {
+func (d *Driver) executeInAutoCommitMode(ctx context.Context, conn *sql.Conn, commands []base.Statement, nonTransactionStmts []base.Statement, remainingSQLsIndex, nonTransactionStmtsIndex []int, originalIndex []int32, opts db.ExecuteOptions, connectionID string) (int64, error) {
var totalRowsAffected int64
// Execute all statements (including non-transactional ones) in order
- allCommands := make([]base.SingleSQL, 0, len(commands)+len(nonTransactionStmts))
+ allCommands := make([]base.Statement, 0, len(commands)+len(nonTransactionStmts))
allIndexes := make([]int, 0, len(commands)+len(nonTransactionStmts))
// Merge commands and non-transactional statements while preserving original order
@@ -417,7 +417,7 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string
if err != nil {
return nil, err
}
- singleSQLs = base.FilterEmptySQL(singleSQLs)
+ singleSQLs = base.FilterEmptyStatements(singleSQLs)
if len(singleSQLs) == 0 {
return nil, nil
}
diff --git a/backend/plugin/db/trino/trino.go b/backend/plugin/db/trino/trino.go
index 02ffc5ded0..02ba24c867 100644
--- a/backend/plugin/db/trino/trino.go
+++ b/backend/plugin/db/trino/trino.go
@@ -168,12 +168,12 @@ func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteO
return 0, errors.Wrapf(err, "failed to split sql")
}
- singleSQLs := make([]base.SingleSQL, len(rawStmts))
+ singleSQLs := make([]base.Statement, len(rawStmts))
for i, stmt := range rawStmts {
- singleSQLs[i] = base.SingleSQL{Text: stmt}
+ singleSQLs[i] = base.Statement{Text: stmt}
}
- commands, originalIndex := base.FilterEmptySQLWithIndexes(singleSQLs)
+ commands, originalIndex := base.FilterEmptyStatementsWithIndexes(singleSQLs)
if len(commands) == 0 {
return 0, nil
}
diff --git a/backend/plugin/parser/base/base.go b/backend/plugin/parser/base/base.go
index c4bc281a41..6c1a5c6e8c 100644
--- a/backend/plugin/parser/base/base.go
+++ b/backend/plugin/parser/base/base.go
@@ -9,29 +9,6 @@ import (
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
)
-// SingleSQL is a separate SQL split from multi-SQL.
-type SingleSQL struct {
- Text string
- // BaseLine is the line number of the first line of the SQL in the original SQL.
- // HINT: ZERO based.
- BaseLine int
- // The inclusive start position of the SQL starts in the original SQL.
- Start *storepb.Position
- // The inclusive end position of the SQL ends in the original SQL.
- End *storepb.Position
- // The sql is empty, such as `/* comments */;` or just `;`.
- Empty bool
-
- // ByteOffsetStart is the start position of the sql.
- // This field may not be present for every engine.
- // ByteOffsetStart is intended for sql execution log display. It may not represent the actual sql that is sent to the database.
- ByteOffsetStart int
- // ByteOffsetEnd is the end position of the sql.
- // This field may not be present for every engine.
- // ByteOffsetEnd is intended for sql execution log display. It may not represent the actual sql that is sent to the database.
- ByteOffsetEnd int
-}
-
// SyntaxError is a syntax error.
type SyntaxError struct {
Position *storepb.Position
@@ -125,28 +102,6 @@ func (*ParseErrorListener) ReportContextSensitivity(recognizer antlr.Parser, dfa
antlr.ConsoleErrorListenerINSTANCE.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs)
}
-func FilterEmptySQL(list []SingleSQL) []SingleSQL {
- var result []SingleSQL
- for _, sql := range list {
- if !sql.Empty {
- result = append(result, sql)
- }
- }
- return result
-}
-
-func FilterEmptySQLWithIndexes(list []SingleSQL) ([]SingleSQL, []int32) {
- var result []SingleSQL
- var originalIndex []int32
- for i, sql := range list {
- if !sql.Empty {
- result = append(result, sql)
- originalIndex = append(originalIndex, int32(i))
- }
- }
- return result, originalIndex
-}
-
func GetOffsetLength(total int) int {
length := 1
for {
diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.go
index caee8694d2..7103200715 100644
--- a/backend/plugin/parser/base/interface.go
+++ b/backend/plugin/parser/base/interface.go
@@ -34,7 +34,7 @@ var (
type ValidateSQLForEditorFunc func(string) (bool, bool, error)
type ExtractChangedResourcesFunc func(string, string, *model.DatabaseMetadata, []AST, string) (*ChangeSummary, error)
-type SplitMultiSQLFunc func(string) ([]SingleSQL, error)
+type SplitMultiSQLFunc func(string) ([]Statement, error)
type CompletionFunc func(ctx context.Context, cCtx CompletionContext, statement string, caretLine int, caretOffset int) ([]Candidate, error)
type DiagnoseFunc func(ctx context.Context, dCtx DiagnoseContext, statement string) ([]Diagnostic, error)
type StatementRangeFunc func(ctx context.Context, sCtx StatementRangeContext, statement string) ([]Range, error)
@@ -52,9 +52,9 @@ type GenerateRestoreSQLFunc func(ctx context.Context, rCtx RestoreContext, state
// Parser packages can return *ANTLRAST for ANTLR-based parsers or their own concrete types.
type ParseFunc func(statement string) ([]AST, error)
-// ParseStatementsFunc is the interface for parsing SQL statements and returning []Statement.
-// This is the new unified parsing function that returns complete Statement objects.
-type ParseStatementsFunc func(statement string) ([]Statement, error)
+// ParseStatementsFunc is the interface for parsing SQL statements and returning []ParsedStatement.
+// This is the new unified parsing function that returns complete ParsedStatement objects with AST.
+type ParseStatementsFunc func(statement string) ([]ParsedStatement, error)
// GetStatementTypesFunc returns the types of statements in the ASTs.
// Statement types include: INSERT, UPDATE, DELETE (DML), CREATE_TABLE, ALTER_TABLE, DROP_TABLE, etc. (DDL).
@@ -111,7 +111,7 @@ func RegisterSplitterFunc(engine storepb.Engine, f SplitMultiSQLFunc) {
}
// SplitMultiSQL splits statement into a slice of the single SQL.
-func SplitMultiSQL(engine storepb.Engine, statement string) ([]SingleSQL, error) {
+func SplitMultiSQL(engine storepb.Engine, statement string) ([]Statement, error) {
f, ok := splitters[engine]
if !ok {
return nil, errors.Errorf("engine %s is not supported", engine)
@@ -291,9 +291,9 @@ func RegisterParseStatementsFunc(engine storepb.Engine, f ParseStatementsFunc) {
statementParsers[engine] = f
}
-// ParseStatements parses the SQL statement and returns Statement objects with both text and AST.
+// ParseStatements parses the SQL statement and returns ParsedStatement objects with both text and AST.
// This is the new unified parsing function.
-func ParseStatements(engine storepb.Engine, statement string) ([]Statement, error) {
+func ParseStatements(engine storepb.Engine, statement string) ([]ParsedStatement, error) {
f, ok := statementParsers[engine]
if !ok {
return nil, errors.Errorf("engine %s is not supported for ParseStatements", engine)
diff --git a/backend/plugin/parser/base/lexer.go b/backend/plugin/parser/base/lexer.go
index 812d8e7536..d37afd0c35 100644
--- a/backend/plugin/parser/base/lexer.go
+++ b/backend/plugin/parser/base/lexer.go
@@ -65,7 +65,7 @@ func IsEmpty(tokens []antlr.Token, semi int) bool {
// - statement: The original SQL statement string (used for position conversion)
//
// Returns:
-// - A slice of SingleSQL, each representing one statement with its text, position, and metadata
+// - A slice of Statement, each representing one statement with its text, position, and metadata
//
// Example usage:
//
@@ -73,10 +73,10 @@ func IsEmpty(tokens []antlr.Token, semi int) bool {
// stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
// stream.Fill()
// return SplitSQLByLexer(stream, parser.SnowflakeLexerSEMI, statement)
-func SplitSQLByLexer(stream *antlr.CommonTokenStream, semiTokenType int, statement string) ([]SingleSQL, error) {
+func SplitSQLByLexer(stream *antlr.CommonTokenStream, semiTokenType int, statement string) ([]Statement, error) {
tokens := stream.GetAllTokens()
var buf []antlr.Token
- var sqls []SingleSQL
+ var sqls []Statement
for i, token := range tokens {
// Collect all tokens except the last one (EOF)
@@ -103,7 +103,7 @@ func SplitSQLByLexer(stream *antlr.CommonTokenStream, semiTokenType int, stateme
// Get the position of the first default channel token for Start position
antlrPosition := FirstDefaultChannelTokenPosition(buf)
- sqls = append(sqls, SingleSQL{
+ sqls = append(sqls, Statement{
Text: bufStr.String(),
BaseLine: buf[0].GetLine() - 1, // BaseLine is the offset of the first token
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
diff --git a/backend/plugin/parser/base/statement.go b/backend/plugin/parser/base/statement.go
index 6faa850abc..ce18ae61bf 100644
--- a/backend/plugin/parser/base/statement.go
+++ b/backend/plugin/parser/base/statement.go
@@ -4,23 +4,37 @@ import (
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
)
-// Statement represents a single SQL statement with both text and parsed AST.
-// This is the unified type that combines SingleSQL (text-based) and AST (tree-based).
+// Statement is the result of splitting SQL (text + positions, no AST).
type Statement struct {
- // Text content
- Text string
+ // Text is the SQL text content.
+ Text string
+ // Empty indicates if the sql is empty, such as `/* comments */;` or just `;`.
Empty bool
- // Position tracking (1-based)
- StartPosition *storepb.Position
- EndPosition *storepb.Position
+ // BaseLine is the line number of the first line of the SQL in the original SQL.
+ // HINT: ZERO based. This is kept for backward compatibility with advisor code.
+ BaseLine int
- // Byte offsets for execution tracking
+ // Start is the inclusive start position of the SQL in the original SQL (1-based).
+ Start *storepb.Position
+ // End is the inclusive end position of the SQL in the original SQL (1-based).
+ End *storepb.Position
+
+ // ByteOffsetStart is the start byte position of the sql.
+ // This field may not be present for every engine.
+ // ByteOffsetStart is intended for sql execution log display. It may not represent the actual sql that is sent to the database.
ByteOffsetStart int
- ByteOffsetEnd int
+ // ByteOffsetEnd is the end byte position of the sql.
+ // This field may not be present for every engine.
+ // ByteOffsetEnd is intended for sql execution log display. It may not represent the actual sql that is sent to the database.
+ ByteOffsetEnd int
+}
- // Parsed tree (always present after Parse)
- AST AST
+// ParsedStatement is the result of parsing SQL (Statement + AST).
+// AST is guaranteed to be non-nil after successful parsing.
+type ParsedStatement struct {
+ Statement // embedded - access fields directly like ps.Text, ps.Start
+ AST AST // always non-nil after parsing
}
// FilterEmptyStatements removes empty statements from the list.
@@ -47,46 +61,35 @@ func FilterEmptyStatementsWithIndexes(list []Statement) ([]Statement, []int32) {
return result, originalIndex
}
-// SingleSQLToStatement converts a SingleSQL to a Statement without AST.
-// The AST field will be nil. Use this for incremental migration.
-func SingleSQLToStatement(sql SingleSQL) Statement {
- return Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
- AST: nil,
- }
-}
-
-// SingleSQLsToStatements converts a slice of SingleSQL to Statements without AST.
-func SingleSQLsToStatements(sqls []SingleSQL) []Statement {
- result := make([]Statement, len(sqls))
- for i, sql := range sqls {
- result[i] = SingleSQLToStatement(sql)
+// FilterEmptyParsedStatements removes empty parsed statements from the list.
+func FilterEmptyParsedStatements(list []ParsedStatement) []ParsedStatement {
+ var result []ParsedStatement
+ for _, stmt := range list {
+ if !stmt.Empty {
+ result = append(result, stmt)
+ }
}
return result
}
-// StatementToSingleSQL converts a Statement back to SingleSQL.
-// The AST is discarded. Use this for backward compatibility.
-func StatementToSingleSQL(stmt Statement) SingleSQL {
- return SingleSQL{
- Text: stmt.Text,
- Empty: stmt.Empty,
- Start: stmt.StartPosition,
- End: stmt.EndPosition,
- ByteOffsetStart: stmt.ByteOffsetStart,
- ByteOffsetEnd: stmt.ByteOffsetEnd,
- // Note: BaseLine is not preserved as Statement uses 1-based StartPosition
+// FilterEmptyParsedStatementsWithIndexes removes empty parsed statements and returns original indexes.
+func FilterEmptyParsedStatementsWithIndexes(list []ParsedStatement) ([]ParsedStatement, []int32) {
+ var result []ParsedStatement
+ var originalIndex []int32
+ for i, stmt := range list {
+ if !stmt.Empty {
+ result = append(result, stmt)
+ originalIndex = append(originalIndex, int32(i))
+ }
}
+ return result, originalIndex
}
-// ExtractASTs extracts ASTs from a slice of Statements.
-// This is useful for backward compatibility when migrating from []AST to []Statement.
-func ExtractASTs(stmts []Statement) []AST {
+// ExtractASTs extracts non-nil ASTs from a slice of ParsedStatements.
+// Empty statements (with nil AST) are skipped.
+// Returns nil if no ASTs are found (preserves nil-check compatibility).
+// This is useful for backward compatibility when migrating from []AST to []ParsedStatement.
+func ExtractASTs(stmts []ParsedStatement) []AST {
var asts []AST
for _, stmt := range stmts {
if stmt.AST != nil {
@@ -95,3 +98,13 @@ func ExtractASTs(stmts []Statement) []AST {
}
return asts
}
+
+// ExtractStatements extracts Statements from a slice of ParsedStatements.
+// This is useful when you only need the text/position information without AST.
+func ExtractStatements(stmts []ParsedStatement) []Statement {
+ result := make([]Statement, len(stmts))
+ for i, stmt := range stmts {
+ result[i] = stmt.Statement
+ }
+ return result
+}
diff --git a/backend/plugin/parser/base/statement_test.go b/backend/plugin/parser/base/statement_test.go
index 5bb3be8bf2..1a0bb9acfd 100644
--- a/backend/plugin/parser/base/statement_test.go
+++ b/backend/plugin/parser/base/statement_test.go
@@ -36,43 +36,79 @@ func TestFilterEmptyStatementsWithIndexes(t *testing.T) {
require.Equal(t, []int32{0, 2}, indexes)
}
-func TestSingleSQLToStatement(t *testing.T) {
- sql := SingleSQL{
- Text: "SELECT 1",
- Empty: false,
- Start: &storepb.Position{Line: 1, Column: 1},
- End: &storepb.Position{Line: 1, Column: 9},
- ByteOffsetStart: 0,
- ByteOffsetEnd: 8,
+func TestFilterEmptyParsedStatements(t *testing.T) {
+ statements := []ParsedStatement{
+ {Statement: Statement{Text: "SELECT 1", Empty: false}, AST: &ANTLRAST{}},
+ {Statement: Statement{Text: "", Empty: true}, AST: &ANTLRAST{}},
+ {Statement: Statement{Text: "SELECT 2", Empty: false}, AST: &ANTLRAST{}},
}
- stmt := SingleSQLToStatement(sql)
+ result := FilterEmptyParsedStatements(statements)
- require.Equal(t, sql.Text, stmt.Text)
- require.Equal(t, sql.Empty, stmt.Empty)
- require.Equal(t, sql.Start, stmt.StartPosition)
- require.Equal(t, sql.End, stmt.EndPosition)
- require.Equal(t, sql.ByteOffsetStart, stmt.ByteOffsetStart)
- require.Equal(t, sql.ByteOffsetEnd, stmt.ByteOffsetEnd)
- require.Nil(t, stmt.AST)
+ require.Len(t, result, 2)
+ require.Equal(t, "SELECT 1", result[0].Text)
+ require.Equal(t, "SELECT 2", result[1].Text)
+}
+
+func TestFilterEmptyParsedStatementsWithIndexes(t *testing.T) {
+ statements := []ParsedStatement{
+ {Statement: Statement{Text: "SELECT 1", Empty: false}, AST: &ANTLRAST{}},
+ {Statement: Statement{Text: "", Empty: true}, AST: &ANTLRAST{}},
+ {Statement: Statement{Text: "SELECT 2", Empty: false}, AST: &ANTLRAST{}},
+ }
+
+ result, indexes := FilterEmptyParsedStatementsWithIndexes(statements)
+
+ require.Len(t, result, 2)
+ require.Equal(t, []int32{0, 2}, indexes)
}
-func TestStatementToSingleSQL(t *testing.T) {
- stmt := Statement{
- Text: "SELECT 1",
- Empty: false,
- StartPosition: &storepb.Position{Line: 1, Column: 1},
- EndPosition: &storepb.Position{Line: 1, Column: 9},
- ByteOffsetStart: 0,
- ByteOffsetEnd: 8,
+func TestExtractASTs(t *testing.T) {
+ ast1 := &ANTLRAST{StartPosition: &storepb.Position{Line: 1}}
+ ast2 := &ANTLRAST{StartPosition: &storepb.Position{Line: 2}}
+
+ statements := []ParsedStatement{
+ {Statement: Statement{Text: "SELECT 1"}, AST: ast1},
+ {Statement: Statement{Text: "SELECT 2"}, AST: ast2},
}
- sql := StatementToSingleSQL(stmt)
+ asts := ExtractASTs(statements)
+
+ require.Len(t, asts, 2)
+ require.Equal(t, ast1, asts[0])
+ require.Equal(t, ast2, asts[1])
+}
+
+func TestExtractStatements(t *testing.T) {
+ statements := []ParsedStatement{
+ {Statement: Statement{Text: "SELECT 1", BaseLine: 0}, AST: &ANTLRAST{}},
+ {Statement: Statement{Text: "SELECT 2", BaseLine: 1}, AST: &ANTLRAST{}},
+ }
+
+ result := ExtractStatements(statements)
+
+ require.Len(t, result, 2)
+ require.Equal(t, "SELECT 1", result[0].Text)
+ require.Equal(t, "SELECT 2", result[1].Text)
+ require.Equal(t, 0, result[0].BaseLine)
+ require.Equal(t, 1, result[1].BaseLine)
+}
+
+func TestParsedStatementEmbedding(t *testing.T) {
+ // Test that ParsedStatement embeds Statement correctly
+ // Fields should be accessible directly
+ ps := ParsedStatement{
+ Statement: Statement{
+ Text: "SELECT 1",
+ BaseLine: 5,
+ Start: &storepb.Position{Line: 6, Column: 1},
+ },
+ AST: &ANTLRAST{StartPosition: &storepb.Position{Line: 6}},
+ }
- require.Equal(t, stmt.Text, sql.Text)
- require.Equal(t, stmt.Empty, sql.Empty)
- require.Equal(t, stmt.StartPosition, sql.Start)
- require.Equal(t, stmt.EndPosition, sql.End)
- require.Equal(t, stmt.ByteOffsetStart, sql.ByteOffsetStart)
- require.Equal(t, stmt.ByteOffsetEnd, sql.ByteOffsetEnd)
+ // Direct access to embedded fields
+ require.Equal(t, "SELECT 1", ps.Text)
+ require.Equal(t, 5, ps.BaseLine)
+ require.Equal(t, int32(6), ps.Start.Line)
+ require.NotNil(t, ps.AST)
}
diff --git a/backend/plugin/parser/bigquery/split.go b/backend/plugin/parser/bigquery/split.go
index 46d70812cc..c08063d297 100644
--- a/backend/plugin/parser/bigquery/split.go
+++ b/backend/plugin/parser/bigquery/split.go
@@ -15,14 +15,14 @@ func init() {
base.RegisterSplitterFunc(storepb.Engine_BIGQUERY, SplitSQL)
}
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
lexer := parser.NewGoogleSQLLexer(antlr.NewInputStream(statement))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
stream.Fill()
tokens := stream.GetAllTokens()
var buf []antlr.Token
- var sqls []base.SingleSQL
+ var sqls []base.Statement
for i, token := range tokens {
if i < len(tokens)-1 {
buf = append(buf, token)
@@ -40,7 +40,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
}
}
antlrPosition := base.FirstDefaultChannelTokenPosition(buf)
- sqls = append(sqls, base.SingleSQL{
+ sqls = append(sqls, base.Statement{
Text: bufStr.String(),
BaseLine: buf[0].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
diff --git a/backend/plugin/parser/bigquery/split_test.go b/backend/plugin/parser/bigquery/split_test.go
index d412e9d694..8fb5d7875e 100644
--- a/backend/plugin/parser/bigquery/split_test.go
+++ b/backend/plugin/parser/bigquery/split_test.go
@@ -15,7 +15,7 @@ type splitTestData struct {
}
type resData struct {
- res []base.SingleSQL
+ res []base.Statement
}
func TestBigQuerySplitMultiSQL(t *testing.T) {
@@ -23,7 +23,7 @@ func TestBigQuerySplitMultiSQL(t *testing.T) {
{
statement: "SELECT 1",
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "SELECT 1",
BaseLine: 0,
@@ -37,7 +37,7 @@ func TestBigQuerySplitMultiSQL(t *testing.T) {
{
statement: "SELECT 1;\n SELECT\n 33;",
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "SELECT 1;",
BaseLine: 0,
diff --git a/backend/plugin/parser/cassandra/cassandra.go b/backend/plugin/parser/cassandra/cassandra.go
index 641887dcef..ca1348f486 100644
--- a/backend/plugin/parser/cassandra/cassandra.go
+++ b/backend/plugin/parser/cassandra/cassandra.go
@@ -40,10 +40,10 @@ func toAST(results []*base.ParseResult) []base.AST {
}
// parseCassandraStatements is the ParseStatementsFunc for Cassandra.
-// Returns []Statement with both text and AST populated.
-func parseCassandraStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions
- singleSQLs, err := SplitSQL(statement)
+// Returns []ParsedStatement with both text and AST populated.
+func parseCassandraStatements(statement string) ([]base.ParsedStatement, error) {
+ // First split to get Statement with text and positions
+ stmts, err := SplitSQL(statement)
if err != nil {
return nil, err
}
@@ -54,30 +54,25 @@ func parseCassandraStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, ParseResult provides AST
- var statements []base.Statement
+ // Combine: Statement provides text/positions, ParseResult provides AST
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(parseResults) {
- stmt.AST = &base.ANTLRAST{
+ if !stmt.Empty && astIndex < len(parseResults) {
+ ps.AST = &base.ANTLRAST{
StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
Tree: parseResults[astIndex].Tree,
Tokens: parseResults[astIndex].Tokens,
}
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
// ParseCassandraSQL parses the given CQL statement by using antlr4. Returns a list of AST and token stream if no error.
diff --git a/backend/plugin/parser/cassandra/split.go b/backend/plugin/parser/cassandra/split.go
index a3517e251f..3146b8ceff 100644
--- a/backend/plugin/parser/cassandra/split.go
+++ b/backend/plugin/parser/cassandra/split.go
@@ -13,7 +13,7 @@ func init() {
}
// SplitSQL splits the input into multiple CQL statements using semicolon as delimiter.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
lexer := cql.NewCqlLexer(antlr.NewInputStream(statement))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
stream.Fill()
diff --git a/backend/plugin/parser/cassandra/split_test.go b/backend/plugin/parser/cassandra/split_test.go
index e844c818a5..a69ac6ad29 100644
--- a/backend/plugin/parser/cassandra/split_test.go
+++ b/backend/plugin/parser/cassandra/split_test.go
@@ -13,7 +13,7 @@ func TestSplitSQL(t *testing.T) {
statement := `SELECT * FROM users;
SELECT * FROM orders;
SELECT * FROM products;`
- want := []base.SingleSQL{
+ want := []base.Statement{
{
Text: "SELECT * FROM users;",
BaseLine: 0,
diff --git a/backend/plugin/parser/cockroachdb/cockroachdb.go b/backend/plugin/parser/cockroachdb/cockroachdb.go
index bc75ae308b..c691cf96bc 100644
--- a/backend/plugin/parser/cockroachdb/cockroachdb.go
+++ b/backend/plugin/parser/cockroachdb/cockroachdb.go
@@ -37,10 +37,10 @@ func parseCockroachDBForRegistry(statement string) ([]base.AST, error) {
}
// parseCockroachDBStatements is the ParseStatementsFunc for CockroachDB.
-// Returns []Statement with both text and AST populated.
-func parseCockroachDBStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions (uses PostgreSQL splitter)
- singleSQLs, err := base.SplitMultiSQL(storepb.Engine_COCKROACHDB, statement)
+// Returns []ParsedStatement with both text and AST populated.
+func parseCockroachDBStatements(statement string) ([]base.ParsedStatement, error) {
+ // First split to get Statement with text and positions (uses PostgreSQL splitter)
+ stmts, err := base.SplitMultiSQL(storepb.Engine_COCKROACHDB, statement)
if err != nil {
return nil, err
}
@@ -51,26 +51,21 @@ func parseCockroachDBStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, AST provides parsed tree
- var statements []base.Statement
+ // Combine: Statement provides text/positions, AST provides parsed tree
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(asts) {
- stmt.AST = asts[astIndex]
+ if !stmt.Empty && astIndex < len(asts) {
+ ps.AST = asts[astIndex]
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
type ParseResult struct {
diff --git a/backend/plugin/parser/cosmosdb/split.go b/backend/plugin/parser/cosmosdb/split.go
index 7e65122f71..cb5d070676 100644
--- a/backend/plugin/parser/cosmosdb/split.go
+++ b/backend/plugin/parser/cosmosdb/split.go
@@ -17,7 +17,7 @@ func init() {
// SplitSQL splits the given SQL statement into multiple SQL statements.
// Note: CosmosDB only supports single SELECT statements, so this returns the entire input as one statement.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
// CosmosDB doesn't support multiple statements or semicolon delimiters.
// The grammar only accepts: root: select EOF
if strings.TrimSpace(statement) == "" {
@@ -67,7 +67,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
lastToken = tokens[len(tokens)-1]
}
- return []base.SingleSQL{
+ return []base.Statement{
{
Text: statement,
BaseLine: 0,
diff --git a/backend/plugin/parser/doris/doris.go b/backend/plugin/parser/doris/doris.go
index 87fa11db86..7a8a9e0561 100644
--- a/backend/plugin/parser/doris/doris.go
+++ b/backend/plugin/parser/doris/doris.go
@@ -37,10 +37,10 @@ func toAST(results []*base.ParseResult) []base.AST {
}
// parseDorisStatements is the ParseStatementsFunc for Doris.
-// Returns []Statement with both text and AST populated.
-func parseDorisStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions
- singleSQLs, err := SplitSQL(statement)
+// Returns []ParsedStatement with both text and AST populated.
+func parseDorisStatements(statement string) ([]base.ParsedStatement, error) {
+ // First split to get Statement with text and positions
+ stmts, err := SplitSQL(statement)
if err != nil {
return nil, err
}
@@ -51,30 +51,25 @@ func parseDorisStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, ParseResult provides AST
- var statements []base.Statement
+ // Combine: Statement provides text/positions, ParseResult provides AST
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(parseResults) {
- stmt.AST = &base.ANTLRAST{
+ if !stmt.Empty && astIndex < len(parseResults) {
+ ps.AST = &base.ANTLRAST{
StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
Tree: parseResults[astIndex].Tree,
Tokens: parseResults[astIndex].Tokens,
}
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
// ParseDorisSQL parses the given SQL statement by using antlr4. Returns a list of AST and token stream if no error.
diff --git a/backend/plugin/parser/doris/split.go b/backend/plugin/parser/doris/split.go
index 11bec9b3b0..39cd3ef308 100644
--- a/backend/plugin/parser/doris/split.go
+++ b/backend/plugin/parser/doris/split.go
@@ -14,7 +14,7 @@ func init() {
}
// SplitSQL splits the input into multiple SQL statements using semicolon as delimiter.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
lexer := parser.NewDorisLexer(antlr.NewInputStream(statement))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
stream.Fill()
diff --git a/backend/plugin/parser/mysql/completion.go b/backend/plugin/parser/mysql/completion.go
index c14734f181..a7e80998df 100644
--- a/backend/plugin/parser/mysql/completion.go
+++ b/backend/plugin/parser/mysql/completion.go
@@ -1215,7 +1215,7 @@ func prepareTrickyParserAndScanner(statement string, caretLine int, caretOffset
return parser, lexer, scanner
}
-func notEmptySQLCount(list []base.SingleSQL) int {
+func notEmptySQLCount(list []base.Statement) int {
count := 0
for _, sql := range list {
if !sql.Empty {
diff --git a/backend/plugin/parser/mysql/mysql.go b/backend/plugin/parser/mysql/mysql.go
index 9ed58b00e1..be0210d3be 100644
--- a/backend/plugin/parser/mysql/mysql.go
+++ b/backend/plugin/parser/mysql/mysql.go
@@ -52,10 +52,10 @@ func toAST(results []*base.ParseResult) []base.AST {
}
// parseMySQLStatements is the ParseStatementsFunc for MySQL, MariaDB, and OceanBase.
-// Returns []Statement with both text and AST populated.
-func parseMySQLStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions
- singleSQLs, err := SplitSQL(statement)
+// Returns []ParsedStatement with both text and AST populated.
+func parseMySQLStatements(statement string) ([]base.ParsedStatement, error) {
+ // First split to get Statement with text and positions
+ stmts, err := SplitSQL(statement)
if err != nil {
return nil, err
}
@@ -66,31 +66,26 @@ func parseMySQLStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, ParseResult provides AST
+ // Combine: Statement provides text/positions, ParseResult provides AST
// Note: parseResults may have fewer items if some statements are empty
- var statements []base.Statement
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(parseResults) {
- stmt.AST = &base.ANTLRAST{
+ if !stmt.Empty && astIndex < len(parseResults) {
+ ps.AST = &base.ANTLRAST{
StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
Tree: parseResults[astIndex].Tree,
Tokens: parseResults[astIndex].Tokens,
}
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
// ParseMySQL parses the given SQL statement and returns the AST.
@@ -348,7 +343,7 @@ func ExtractDelimiter(stmt string) (string, error) {
return "", errors.Errorf("cannot extract delimiter from %q", stmt)
}
-func hasDelimiter(statement string) (bool, []base.SingleSQL, error) {
+func hasDelimiter(statement string) (bool, []base.Statement, error) {
// use splitTiDBMultiSQL to check if the statement has delimiter
t := tokenizer.NewTokenizer(statement)
list, err := t.SplitTiDBMultiSQL()
diff --git a/backend/plugin/parser/mysql/mysql_test.go b/backend/plugin/parser/mysql/mysql_test.go
index 1e5f5bf070..a00f35990a 100644
--- a/backend/plugin/parser/mysql/mysql_test.go
+++ b/backend/plugin/parser/mysql/mysql_test.go
@@ -456,7 +456,7 @@ func TestParseMySQLStatements(t *testing.T) {
require.NoError(t, err)
// Filter empty statements for assertion
- statements = base.FilterEmptyStatements(statements)
+ statements = base.FilterEmptyParsedStatements(statements)
require.Len(t, statements, 2)
@@ -464,7 +464,7 @@ func TestParseMySQLStatements(t *testing.T) {
require.Equal(t, "SELECT 1;", statements[0].Text)
require.False(t, statements[0].Empty)
require.NotNil(t, statements[0].AST)
- require.NotNil(t, statements[0].StartPosition)
+ require.NotNil(t, statements[0].Start)
// Check second statement
require.Contains(t, statements[1].Text, "SELECT 2")
diff --git a/backend/plugin/parser/mysql/restore.go b/backend/plugin/parser/mysql/restore.go
index 5dce1840d1..e5e772fba8 100644
--- a/backend/plugin/parser/mysql/restore.go
+++ b/backend/plugin/parser/mysql/restore.go
@@ -23,7 +23,7 @@ func init() {
}
func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
- originalSQL, err := extractSingleSQL(statement, backupItem)
+ originalSQL, err := extractStatement(statement, backupItem)
if err != nil {
return "", errors.Errorf("failed to extract single SQL: %v", err)
}
@@ -87,7 +87,7 @@ func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment str
return buf.String(), nil
}
-func extractSingleSQL(statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
+func extractStatement(statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
if backupItem == nil {
return "", errors.Errorf("backup item is nil")
}
diff --git a/backend/plugin/parser/mysql/split.go b/backend/plugin/parser/mysql/split.go
index 305ff4f017..ac55de18a7 100644
--- a/backend/plugin/parser/mysql/split.go
+++ b/backend/plugin/parser/mysql/split.go
@@ -19,7 +19,7 @@ func init() {
}
// SplitSQL splits the given SQL statement into multiple SQL statements.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
lexer := parser.NewMySQLLexer(antlr.NewInputStream(statement))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
@@ -32,8 +32,8 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
return list, nil
}
-func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([]base.SingleSQL, error) {
- var result []base.SingleSQL
+func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([]base.Statement, error) {
+ var result []base.Statement
delimiter := ";"
tokens := stream.GetAllTokens()
start := 0
@@ -59,7 +59,7 @@ func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : i+1])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[i]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -83,7 +83,7 @@ func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:newStart])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
// Use a single semicolon instead of the user defined delimiter.
Text: stream.GetTextFromTokens(tokens[start], tokens[i-1]) + ";",
BaseLine: tokens[start].GetLine() - 1,
@@ -107,7 +107,7 @@ func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[endPos-1]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -164,7 +164,7 @@ func hasDelimiterStatement(stream *antlr.CommonTokenStream) bool {
return false
}
-func splitByParser(statement string, lexer *parser.MySQLLexer, stream *antlr.CommonTokenStream) ([]base.SingleSQL, error) {
+func splitByParser(statement string, lexer *parser.MySQLLexer, stream *antlr.CommonTokenStream) ([]base.Statement, error) {
p := parser.NewMySQLParser(stream)
lexerErrorListener := &base.ParseErrorListener{
Statement: statement,
@@ -190,7 +190,7 @@ func splitByParser(statement string, lexer *parser.MySQLLexer, stream *antlr.Com
return nil, parserErrorListener.Err
}
- var result []base.SingleSQL
+ var result []base.Statement
tokens := stream.GetAllTokens()
start := 0
@@ -199,7 +199,7 @@ func splitByParser(statement string, lexer *parser.MySQLLexer, stream *antlr.Com
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -217,7 +217,7 @@ func splitByParser(statement string, lexer *parser.MySQLLexer, stream *antlr.Com
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[eofPos-1]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -236,13 +236,13 @@ type openParenthesis struct {
pos int
}
-func splitMySQLStatement(stream *antlr.CommonTokenStream, statement string) ([]base.SingleSQL, error) {
+func splitMySQLStatement(stream *antlr.CommonTokenStream, statement string) ([]base.Statement, error) {
stream.Fill()
if hasDelimiterStatement(stream) {
return splitDelimiterModeSQL(stream, statement)
}
- var result []base.SingleSQL
+ var result []base.Statement
tokens := stream.GetAllTokens()
var beginCaseStack, ifStack, loopStack, whileStack, repeatStack []*openParenthesis
@@ -377,7 +377,7 @@ func splitMySQLStatement(stream *antlr.CommonTokenStream, statement string) ([]b
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -395,7 +395,7 @@ func splitMySQLStatement(stream *antlr.CommonTokenStream, statement string) ([]b
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[eofPos-1]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
diff --git a/backend/plugin/parser/mysql/split_test.go b/backend/plugin/parser/mysql/split_test.go
index 2b646cf9c5..83c7e1309f 100644
--- a/backend/plugin/parser/mysql/split_test.go
+++ b/backend/plugin/parser/mysql/split_test.go
@@ -21,7 +21,7 @@ type splitTestData struct {
}
type resData struct {
- res []base.SingleSQL
+ res []base.Statement
err string
}
@@ -54,7 +54,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
SELECT x;
`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: ` CREATE PROCEDURE dorepeat(p1 INT)
BEGIN
@@ -198,7 +198,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
)
FROM t; SELECT * FROM t;`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `
SELECT
@@ -318,7 +318,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
{
statement: `select * from t;select "\"" where true;`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `select * from t;`,
Start: &storepb.Position{Line: 1, Column: 1},
@@ -337,7 +337,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
-- klsjdflkjaskldfj
`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "-- klsjdfjasldf\n\t\t\t-- klsjdflkjaskldfj\n",
Start: &storepb.Position{Line: 3, Column: 1},
@@ -351,7 +351,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
statement: `select * from t;
/* sdfasdf */`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `select * from t;`,
End: &storepb.Position{Line: 1, Column: 16},
@@ -372,7 +372,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
/* sdfasdf */;
select * from t;`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `select * from t;`,
Start: &storepb.Position{Line: 1, Column: 1},
@@ -409,7 +409,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
END ;`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "CREATE DEFINER=`root`@`%` FUNCTION `CalcIncome`( starting_value INT ) RETURNS int\n" +
`BEGIN
@@ -434,7 +434,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
{
statement: bigSQL,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: bigSQL,
Start: &storepb.Position{Line: 1, Column: 1},
@@ -446,7 +446,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
{
statement: " CREATE TABLE t(a int); CREATE TABLE t1(a int)",
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: " CREATE TABLE t(a int);",
Start: &storepb.Position{Line: 1, Column: 5},
@@ -464,7 +464,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
statement: "CREATE TABLE `tech_Book`(id int, name varchar(255));\n" +
"INSERT INTO `tech_Book` VALUES (0, 'abce_ksdf'), (1, 'lks''kjsafa\\'jdfl;\"ka');",
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "CREATE TABLE `tech_Book`(id int, name varchar(255));",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -487,7 +487,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
# this is the comment.
INSERT INTO tech_Book VALUES (0, 'abce_ksdf'), (1, 'lks''kjsafa\'jdfl;"ka');`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "\n\t\t\t\t\t\t/* this is the comment. */\n\t\t\t\t\t\tCREATE /* inline comment */TABLE tech_Book(id int, name varchar(255));",
Start: &storepb.Position{Line: 3, Column: 7},
@@ -520,7 +520,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
SELECT @x;
`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "# test for defining stored programs\n\t\t\t\t\t\tCREATE PROCEDURE dorepeat(p1 INT)\n\t\t\t\t\t\tBEGIN\n\t\t\t\t\t\t\tSET @x = 0;\n\t\t\t\t\t\t\tREPEAT SET @x = @x + 1; UNTIL @x > p1 END REPEAT;\n\t\t\t\t\t\tEND\n\t\t\t\t\t\t;",
Start: &storepb.Position{Line: 2, Column: 7},
@@ -562,7 +562,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
SELECT @x;
`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "# test for defining stored programs\n\t\t\t\t\t\tCREATE PROCEDURE dorepeat(p1 INT)\n\t\t\t\t\t\t/* This is a comment */\n\t\t\t\t\t\tBEGIN\n\t\t\t\t\t\t\tSET @x = 0;\n\t\t\t\t\t\t\tREPEAT SET @x = @x + 1; UNTIL @x > p1 END REPEAT;\n\t\t\t\t\t\tEND\n\t\t\t\t\t\t;",
End: &storepb.Position{Line: 8, Column: 7},
@@ -594,7 +594,7 @@ func TestMySQLSplitMultiSQL(t *testing.T) {
// test for Windows
statement: `CREATE TABLE t` + "\r\n" + `(a int);` + "\r\n" + `CREATE TABLE t1(b int);`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "CREATE TABLE t\r\n(a int);",
BaseLine: 0,
diff --git a/backend/plugin/parser/partiql/completion.go b/backend/plugin/parser/partiql/completion.go
index eb5a944547..55ce5f8073 100644
--- a/backend/plugin/parser/partiql/completion.go
+++ b/backend/plugin/parser/partiql/completion.go
@@ -586,7 +586,7 @@ func skipHeadingSQLs(statement string, caretLine int, caretOffset int) (string,
return buf.String(), newCaretLine, newCaretOffset
}
-func notEmptySQLCount(list []base.SingleSQL) int {
+func notEmptySQLCount(list []base.Statement) int {
count := 0
for _, sql := range list {
if !sql.Empty {
diff --git a/backend/plugin/parser/partiql/partiql.go b/backend/plugin/parser/partiql/partiql.go
index 36baa9d503..db2f113bdb 100644
--- a/backend/plugin/parser/partiql/partiql.go
+++ b/backend/plugin/parser/partiql/partiql.go
@@ -41,10 +41,10 @@ func toAST(results []*base.ParseResult) []base.AST {
}
// parsePartiQLStatements is the ParseStatementsFunc for PartiQL (DynamoDB).
-// Returns []Statement with both text and AST populated.
-func parsePartiQLStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions
- singleSQLs, err := SplitSQL(statement)
+// Returns []ParsedStatement with both text and AST populated.
+func parsePartiQLStatements(statement string) ([]base.ParsedStatement, error) {
+ // First split to get Statement with text and positions
+ stmts, err := SplitSQL(statement)
if err != nil {
return nil, err
}
@@ -55,30 +55,25 @@ func parsePartiQLStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, ParseResult provides AST
- var statements []base.Statement
+ // Combine: Statement provides text/positions, ParseResult provides AST
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(parseResults) {
- stmt.AST = &base.ANTLRAST{
+ if !stmt.Empty && astIndex < len(parseResults) {
+ ps.AST = &base.ANTLRAST{
StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
Tree: parseResults[astIndex].Tree,
Tokens: parseResults[astIndex].Tokens,
}
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
// ParsePartiQL parses the given PartiQL statement by using antlr4. Returns a list of AST and token stream if no error.
diff --git a/backend/plugin/parser/partiql/split.go b/backend/plugin/parser/partiql/split.go
index 83685685de..b7f59a73d1 100644
--- a/backend/plugin/parser/partiql/split.go
+++ b/backend/plugin/parser/partiql/split.go
@@ -13,7 +13,7 @@ func init() {
}
// SplitSQL splits the input into multiple SQL statements using semicolon as delimiter.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
lexer := parser.NewPartiQLLexer(antlr.NewInputStream(statement))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
stream.Fill()
diff --git a/backend/plugin/parser/partiql/split_test.go b/backend/plugin/parser/partiql/split_test.go
index f61e303c85..e324cc2768 100644
--- a/backend/plugin/parser/partiql/split_test.go
+++ b/backend/plugin/parser/partiql/split_test.go
@@ -15,7 +15,7 @@ func TestSplitSQL(t *testing.T) {
INSERT INTO Music VALUE {'AlbumTitle': 'The Dark Side of the Moon', 'Artist': 'Pink Floyd', 'Awards': 300, 'SongTitle': 'Money02'};
INSERT INTO Music VALUE {'AlbumTitle': 'The Dark Side of the Moon', 'Artist': 'Pink Floyd', 'Awards': 300, 'SongTitle': 'Money03'};
DELETE FROM Music WHERE Artist = 'Pink Floyd' AND SongTitle = 'Money02'`
- want := []base.SingleSQL{
+ want := []base.Statement{
{
Text: "DELETE FROM Music WHERE Artist = 'Pink Floyd' AND SongTitle = 'Money';",
BaseLine: 0,
diff --git a/backend/plugin/parser/pg/completion.go b/backend/plugin/parser/pg/completion.go
index 28fec80369..6f5fa9cd2e 100644
--- a/backend/plugin/parser/pg/completion.go
+++ b/backend/plugin/parser/pg/completion.go
@@ -1251,7 +1251,7 @@ func prepareParserAndScanner(statement string, caretLine int, caretOffset int) (
func skipHeadingSQLs(statement string, caretLine int, caretOffset int) (string, int, int) {
newCaretLine, newCaretOffset := caretLine, caretOffset
list, err := SplitSQL(statement)
- if err != nil || len(base.FilterEmptySQL(list)) <= 1 {
+ if err != nil || len(base.FilterEmptyStatements(list)) <= 1 {
return statement, caretLine, caretOffset
}
diff --git a/backend/plugin/parser/pg/pg.go b/backend/plugin/parser/pg/pg.go
index 116e0e0383..c692f0fe1c 100644
--- a/backend/plugin/parser/pg/pg.go
+++ b/backend/plugin/parser/pg/pg.go
@@ -40,10 +40,10 @@ func toAST(results []*base.ParseResult) []base.AST {
}
// parsePgStatements is the ParseStatementsFunc for PostgreSQL.
-// Returns []Statement with both text and AST populated.
-func parsePgStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions
- singleSQLs, err := SplitSQL(statement)
+// Returns []ParsedStatement with both text and AST populated.
+func parsePgStatements(statement string) ([]base.ParsedStatement, error) {
+ // First split to get Statement with text and positions
+ stmts, err := SplitSQL(statement)
if err != nil {
return nil, err
}
@@ -54,30 +54,25 @@ func parsePgStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, ParseResult provides AST
- var statements []base.Statement
+ // Combine: Statement provides text/positions, ParseResult provides AST
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(parseResults) {
- stmt.AST = &base.ANTLRAST{
+ if !stmt.Empty && astIndex < len(parseResults) {
+ ps.AST = &base.ANTLRAST{
StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
Tree: parseResults[astIndex].Tree,
Tokens: parseResults[astIndex].Tokens,
}
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
// ParsePostgreSQL parses the given SQL and returns a list of ParseResult (one per statement).
diff --git a/backend/plugin/parser/pg/restore.go b/backend/plugin/parser/pg/restore.go
index 0c97312128..1f2ea66681 100644
--- a/backend/plugin/parser/pg/restore.go
+++ b/backend/plugin/parser/pg/restore.go
@@ -25,7 +25,7 @@ func init() {
}
func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
- originalSQL, err := extractSingleSQL(statement, backupItem)
+ originalSQL, err := extractStatement(statement, backupItem)
if err != nil {
return "", errors.Errorf("failed to extract single SQL: %v", err)
}
@@ -240,7 +240,7 @@ func (l *setFieldListener) EnterSet_clause(ctx *parser.Set_clauseContext) {
}
}
-func extractSingleSQL(statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
+func extractStatement(statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
if backupItem == nil {
return "", errors.Errorf("backup item is nil")
}
diff --git a/backend/plugin/parser/pg/split.go b/backend/plugin/parser/pg/split.go
index c34300245c..402887a22b 100644
--- a/backend/plugin/parser/pg/split.go
+++ b/backend/plugin/parser/pg/split.go
@@ -19,7 +19,7 @@ func init() {
}
// SplitSQL splits the given SQL statement into multiple SQL statements.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
lexer := parser.NewPostgreSQLLexer(antlr.NewInputStream(statement))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
list, err := splitSQLImpl(stream, statement)
@@ -31,7 +31,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
return list, nil
}
-func splitByParser(statement string, lexer *parser.PostgreSQLLexer, stream *antlr.CommonTokenStream) ([]base.SingleSQL, error) {
+func splitByParser(statement string, lexer *parser.PostgreSQLLexer, stream *antlr.CommonTokenStream) ([]base.Statement, error) {
p := parser.NewPostgreSQLParser(stream)
lexerErrorListener := &base.ParseErrorListener{
Statement: statement,
@@ -60,7 +60,7 @@ func splitByParser(statement string, lexer *parser.PostgreSQLLexer, stream *antl
return nil, errors.New("failed to split multiple statements")
}
- var result []base.SingleSQL
+ var result []base.Statement
tokens := stream.GetAllTokens()
start := 0
@@ -69,7 +69,7 @@ func splitByParser(statement string, lexer *parser.PostgreSQLLexer, stream *antl
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -87,7 +87,7 @@ func splitByParser(statement string, lexer *parser.PostgreSQLLexer, stream *antl
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[eofPos-1]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -106,8 +106,8 @@ type openParenthesis struct {
pos int
}
-func splitSQLImpl(stream *antlr.CommonTokenStream, statement string) ([]base.SingleSQL, error) {
- var result []base.SingleSQL
+func splitSQLImpl(stream *antlr.CommonTokenStream, statement string) ([]base.Statement, error) {
+ var result []base.Statement
stream.Fill()
tokens := stream.GetAllTokens()
@@ -188,7 +188,7 @@ func splitSQLImpl(stream *antlr.CommonTokenStream, statement string) ([]base.Sin
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -206,7 +206,7 @@ func splitSQLImpl(stream *antlr.CommonTokenStream, statement string) ([]base.Sin
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[eofPos-1]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
diff --git a/backend/plugin/parser/pg/split_test.go b/backend/plugin/parser/pg/split_test.go
index 73e3e40c93..0583521ce3 100644
--- a/backend/plugin/parser/pg/split_test.go
+++ b/backend/plugin/parser/pg/split_test.go
@@ -18,7 +18,7 @@ type splitTestData struct {
}
type resData struct {
- res []base.SingleSQL
+ res []base.Statement
err string
}
@@ -40,7 +40,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
-- klsjdflkjaskldfj
`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "-- klsjdfjasldf\n\t\t\t-- klsjdflkjaskldfj\n\t\t\t",
BaseLine: 0,
@@ -55,7 +55,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
statement: `select * from t;
/* sdfasdf */`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `select * from t;`,
Start: &storepb.Position{Line: 1, Column: 1},
@@ -75,7 +75,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
/* sdfasdf */;
select * from t;`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `select * from t;`,
Start: &storepb.Position{Line: 1, Column: 1},
@@ -99,7 +99,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
{
statement: bigSQL,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: bigSQL,
Start: &storepb.Position{Line: 1, Column: 1},
@@ -111,7 +111,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
{
statement: " CREATE TABLE t(a int); CREATE TABLE t1(a int)",
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: " CREATE TABLE t(a int);",
Start: &storepb.Position{Line: 1, Column: 5},
@@ -129,7 +129,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
statement: `CREATE TABLE "tech_Book"(id int, name varchar(255));
INSERT INTO "tech_Book" VALUES (0, 'abce_ksdf'), (1, 'lks''kjsafajdfl;"ka');`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `CREATE TABLE "tech_Book"(id int, name varchar(255));`,
Start: &storepb.Position{Line: 1, Column: 1},
@@ -150,7 +150,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
-- this is the comment.
INSERT INTO "tech_Book" VALUES (0, 'abce_ksdf'), (1, 'lks''kjsafajdfl;"ka');`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "\n\t\t\t\t\t\t/* this is the comment. */\n\t\t\t\t\t\tCREATE /* inline comment */TABLE \"tech_Book\"(id int, name varchar(255));",
Start: &storepb.Position{Line: 3, Column: 7},
@@ -176,7 +176,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
$$;
CREATE TABLE t(a int);`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `CREATE PROCEDURE insert_data(a varchar(50), b varchar(50))
LANGUAGE SQL
@@ -209,7 +209,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
$tag_name$;
CREATE TABLE t(a int);`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `CREATE PROCEDURE insert_data(a varchar(50), b varchar(50))
LANGUAGE SQL
@@ -235,7 +235,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
// test for Windows
statement: `CREATE TABLE t` + "\r\n" + `(a int);` + "\r\n" + `CREATE TABLE t1(b int);`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "CREATE TABLE t\r\n(a int);",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -257,7 +257,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
(133,'knuandfan public table id'';create table t(a int, b int);set @text=''\\\\kdaminxkljasdfiebkla.unkonwn''+''abcdef.xyz\\''; local xxxyy.abcddd.mysql @text;------- '),
(1444,'table t xyz abc a''a\\\\\\\\''b"c>?>xxxxxx%}}%%>c<[[?${12344556778990{%}}cake\\');`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "INSERT INTO \"public\".\"table\"(\"id\",\"content\")\n\t\t\tVALUES\n\t\t\t(12,'table column name () { :xna,sydfn,,kasdfyn;}; /////test string/// 0'),\n\t\t\t(133,'knuandfan public table id'';create table t(a int, b int);set @text=''\\\\\\\\kdaminxkljasdfiebkla.unkonwn''+''abcdef.xyz\\\\''; local xxxyy.abcddd.mysql @text;------- '),\n\t\t\t(1444,'table t xyz abc a''a\\\\\\\\\\\\\\\\''b\"c>?>xxxxxx%}}%%>c<[[?${12344556778990{%}}cake\\\\');",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -269,7 +269,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
{
statement: `INSERT INTO t VALUES ('klajfas)`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "INSERT INTO t VALUES ('klajfas)",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -282,7 +282,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
{
statement: `INSERT INTO "t VALUES ('klajfas)`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "INSERT INTO \"t VALUES ('klajfas)",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -294,7 +294,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
{
statement: `/*INSERT INTO "t VALUES ('klajfas)`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "/*INSERT INTO \"t VALUES ('klajfas)",
BaseLine: 0,
@@ -308,7 +308,7 @@ func TestPGSplitMultiSQL(t *testing.T) {
{
statement: `$$INSERT INTO "t VALUES ('klajfas)`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "$$INSERT INTO \"t VALUES ('klajfas)",
Start: &storepb.Position{Line: 1, Column: 1},
diff --git a/backend/plugin/parser/plsql/completion.go b/backend/plugin/parser/plsql/completion.go
index 0af02a7991..5e7e1ea0b6 100644
--- a/backend/plugin/parser/plsql/completion.go
+++ b/backend/plugin/parser/plsql/completion.go
@@ -1107,7 +1107,7 @@ func prepareTrickyParserAndScanner(statement string, caretLine int, caretOffset
return parser, lexer, scanner
}
-func notEmptySQLCount(list []base.SingleSQL) int {
+func notEmptySQLCount(list []base.Statement) int {
count := 0
for _, sql := range list {
if !sql.Empty {
diff --git a/backend/plugin/parser/plsql/plsql.go b/backend/plugin/parser/plsql/plsql.go
index 1b5aa16699..c42b7a9cd3 100644
--- a/backend/plugin/parser/plsql/plsql.go
+++ b/backend/plugin/parser/plsql/plsql.go
@@ -44,10 +44,10 @@ func toAST(results []*base.ParseResult) []base.AST {
}
// parsePLSQLStatements is the ParseStatementsFunc for Oracle (PL/SQL).
-// Returns []Statement with both text and AST populated.
-func parsePLSQLStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions
- singleSQLs, err := SplitSQL(statement)
+// Returns []ParsedStatement with both text and AST populated.
+func parsePLSQLStatements(statement string) ([]base.ParsedStatement, error) {
+ // First split to get Statement with text and positions
+ stmts, err := SplitSQL(statement)
if err != nil {
return nil, err
}
@@ -58,30 +58,25 @@ func parsePLSQLStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, ParseResult provides AST
- var statements []base.Statement
+ // Combine: Statement provides text/positions, ParseResult provides AST
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(parseResults) {
- stmt.AST = &base.ANTLRAST{
+ if !stmt.Empty && astIndex < len(parseResults) {
+ ps.AST = &base.ANTLRAST{
StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
Tree: parseResults[astIndex].Tree,
Tokens: parseResults[astIndex].Tokens,
}
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
type Version struct {
diff --git a/backend/plugin/parser/plsql/split.go b/backend/plugin/parser/plsql/split.go
index 7cbe1b58ad..943c939151 100644
--- a/backend/plugin/parser/plsql/split.go
+++ b/backend/plugin/parser/plsql/split.go
@@ -18,7 +18,7 @@ func init() {
// SplitSQL splits the given SQL statement into multiple SQL statements.
// TODO(zp): Consolidate with split logic in ParsePLSQL?
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
tree, stream, err := ParsePLSQLForStringsManipulation(statement)
if err != nil {
return nil, err
@@ -33,7 +33,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
byteOffsetStart := 0
prevStopTokenIndex := -1
- var result []base.SingleSQL
+ var result []base.Statement
for _, item := range tree.GetChildren() {
if stmt, ok := item.(parser.IUnit_statementContext); ok {
text := ""
@@ -67,7 +67,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
text = strings.TrimRightFunc(text, utils.IsSpaceOrSemicolon)
}
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: text,
Start: common.ConvertANTLRPositionToPosition(
&common.ANTLRPosition{
@@ -94,7 +94,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
return result, nil
}
-func SplitSQLForCompletion(statement string) ([]base.SingleSQL, error) {
+func SplitSQLForCompletion(statement string) ([]base.Statement, error) {
tree, stream, err := ParsePLSQLForStringsManipulation(statement)
if err != nil {
return nil, err
@@ -107,14 +107,14 @@ func SplitSQLForCompletion(statement string) ([]base.SingleSQL, error) {
return nil, nil
}
- var result []base.SingleSQL
+ var result []base.Statement
for _, item := range tree.GetChildren() {
if stmt, ok := item.(parser.IUnit_statementContext); ok {
if isCallStatement(item) && len(result) > 0 {
lastResult := result[len(result)-1]
stopIndex := stmt.GetStop().GetTokenIndex()
lastToken := tokens.Get(stopIndex)
- result[len(result)-1] = base.SingleSQL{
+ result[len(result)-1] = base.Statement{
Text: lastResult.Text + tokens.GetTextFromTokens(stmt.GetStart(), lastToken),
End: common.ConvertANTLRPositionToPosition(
&common.ANTLRPosition{
@@ -135,7 +135,7 @@ func SplitSQLForCompletion(statement string) ([]base.SingleSQL, error) {
lastLine = lastToken.GetLine()
lastColumn = lastToken.GetColumn()
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: tokens.GetTextFromTokens(stmt.GetStart(), lastToken),
End: common.ConvertANTLRPositionToPosition(
&common.ANTLRPosition{
diff --git a/backend/plugin/parser/plsql/split_test.go b/backend/plugin/parser/plsql/split_test.go
index c4b6a28384..cf1999abd6 100644
--- a/backend/plugin/parser/plsql/split_test.go
+++ b/backend/plugin/parser/plsql/split_test.go
@@ -11,7 +11,7 @@ import (
func TestOracleSplitMultiSQL(t *testing.T) {
type resData struct {
- res []base.SingleSQL
+ res []base.Statement
err string
}
type testData struct {
@@ -30,7 +30,7 @@ func TestOracleSplitMultiSQL(t *testing.T) {
create table table$1 (id int)
`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `select * from t`,
ByteOffsetStart: 5,
@@ -59,7 +59,7 @@ INTERVAL (NUMTODSINTERVAL(1, 'DAY'))
)
ONLINE;`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "ALTER TABLE DATA.TEST\nMODIFY PARTITION BY RANGE (TXN_DATE)\nINTERVAL (NUMTODSINTERVAL(1, 'DAY'))\n(\n\tPARTITION TEST_PO VALUES LESS THAN (\n\t\tTO_DATE('2000-01-01 00:00:00', 'SYYYY-MM-DD HH24:MI:SS', 'NLS_CALENDAR=GREGORIAN')\n\t)\n)\nONLINE",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -86,7 +86,7 @@ ONLINE;`,
{
statement: "DROP TABLESPACE xxx INCLUDING CONTENTS CASCADE CONSTRAINTS",
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "DROP TABLESPACE xxx INCLUDING CONTENTS CASCADE CONSTRAINTS",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -99,7 +99,7 @@ ONLINE;`,
{
statement: "CALL my_procedure()",
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "CALL my_procedure()",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -112,7 +112,7 @@ ONLINE;`,
{
statement: "SELECT * FROM t1; SELECT * FROM t2",
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "SELECT * FROM t1",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -138,7 +138,7 @@ BEGIN
END;
/`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "CREATE OR REPLACE PROCEDURE test_proc IS\nBEGIN\n CALL DBMS_OUTPUT.PUT_LINE('Hello');\nEND;",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -160,7 +160,7 @@ BEGIN
END;
/`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "CREATE OR REPLACE PROCEDURE proc1 IS\nBEGIN\n NULL;\nEND;",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -183,7 +183,7 @@ END;
/
SELECT * FROM t2;`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "SELECT * FROM t1",
Start: &storepb.Position{Line: 1, Column: 1},
@@ -207,7 +207,7 @@ SELECT * FROM t2;`,
END;
/`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "BEGIN\n CALL DBMS_OUTPUT.PUT_LINE('Test');\nEND;",
Start: &storepb.Position{Line: 1, Column: 1},
diff --git a/backend/plugin/parser/redshift/completion.go b/backend/plugin/parser/redshift/completion.go
index 3e75af331a..ac15058f47 100644
--- a/backend/plugin/parser/redshift/completion.go
+++ b/backend/plugin/parser/redshift/completion.go
@@ -1264,7 +1264,7 @@ func prepareParserAndScanner(statement string, caretLine int, caretOffset int) (
func skipHeadingSQLs(statement string, caretLine int, caretOffset int) (string, int, int) {
newCaretLine, newCaretOffset := caretLine, caretOffset
list, err := SplitSQL(statement)
- if err != nil || len(base.FilterEmptySQL(list)) <= 1 {
+ if err != nil || len(base.FilterEmptyStatements(list)) <= 1 {
return statement, caretLine, caretOffset
}
diff --git a/backend/plugin/parser/redshift/redshift.go b/backend/plugin/parser/redshift/redshift.go
index dde86b3de4..16139a67d9 100644
--- a/backend/plugin/parser/redshift/redshift.go
+++ b/backend/plugin/parser/redshift/redshift.go
@@ -42,10 +42,10 @@ func toAST(results []*base.ParseResult) []base.AST {
}
// parseRedshiftStatements is the ParseStatementsFunc for Redshift.
-// Returns []Statement with both text and AST populated.
-func parseRedshiftStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions
- singleSQLs, err := SplitSQL(statement)
+// 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
}
@@ -56,30 +56,25 @@ func parseRedshiftStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, ParseResult provides AST
- var statements []base.Statement
+ // Combine: Statement provides text/positions, ParseResult provides AST
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(parseResults) {
- stmt.AST = &base.ANTLRAST{
+ if !stmt.Empty && astIndex < len(parseResults) {
+ ps.AST = &base.ANTLRAST{
StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
Tree: parseResults[astIndex].Tree,
Tokens: parseResults[astIndex].Tokens,
}
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
// ParseRedshift parses the given SQL statement and returns a list of ParseResults.
diff --git a/backend/plugin/parser/redshift/split.go b/backend/plugin/parser/redshift/split.go
index 8cf2b18c99..1373c1c7d3 100644
--- a/backend/plugin/parser/redshift/split.go
+++ b/backend/plugin/parser/redshift/split.go
@@ -20,7 +20,7 @@ func init() {
}
// SplitSQL splits the given SQL statement into multiple SQL statements.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
lexer := parser.NewRedshiftLexer(antlr.NewInputStream(statement))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
list, err := splitSQLImpl(stream, statement)
@@ -32,7 +32,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
return list, nil
}
-func splitByParser(statement string, lexer *parser.RedshiftLexer, stream *antlr.CommonTokenStream) ([]base.SingleSQL, error) {
+func splitByParser(statement string, lexer *parser.RedshiftLexer, stream *antlr.CommonTokenStream) ([]base.Statement, error) {
p := parser.NewRedshiftParser(stream)
lexerErrorListener := &base.ParseErrorListener{
Statement: statement,
@@ -61,7 +61,7 @@ func splitByParser(statement string, lexer *parser.RedshiftLexer, stream *antlr.
return nil, errors.New("failed to split multiple statements")
}
- var result []base.SingleSQL
+ var result []base.Statement
tokens := stream.GetAllTokens()
start := 0
@@ -70,7 +70,7 @@ func splitByParser(statement string, lexer *parser.RedshiftLexer, stream *antlr.
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -88,7 +88,7 @@ func splitByParser(statement string, lexer *parser.RedshiftLexer, stream *antlr.
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[eofPos-1]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -107,8 +107,8 @@ type openParenthesis struct {
pos int
}
-func splitSQLImpl(stream *antlr.CommonTokenStream, statement string) ([]base.SingleSQL, error) {
- var result []base.SingleSQL
+func splitSQLImpl(stream *antlr.CommonTokenStream, statement string) ([]base.Statement, error) {
+ var result []base.Statement
stream.Fill()
tokens := stream.GetAllTokens()
@@ -188,7 +188,7 @@ func splitSQLImpl(stream *antlr.CommonTokenStream, statement string) ([]base.Sin
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
@@ -206,7 +206,7 @@ func splitSQLImpl(stream *antlr.CommonTokenStream, statement string) ([]base.Sin
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[eofPos-1]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
diff --git a/backend/plugin/parser/snowflake/snowflake.go b/backend/plugin/parser/snowflake/snowflake.go
index cf4a95d75e..2a17097025 100644
--- a/backend/plugin/parser/snowflake/snowflake.go
+++ b/backend/plugin/parser/snowflake/snowflake.go
@@ -41,10 +41,10 @@ func toAST(results []*base.ParseResult) []base.AST {
}
// parseSnowflakeStatements is the ParseStatementsFunc for Snowflake.
-// Returns []Statement with both text and AST populated.
-func parseSnowflakeStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions
- singleSQLs, err := SplitSQL(statement)
+// Returns []ParsedStatement with both text and AST populated.
+func parseSnowflakeStatements(statement string) ([]base.ParsedStatement, error) {
+ // First split to get Statement with text and positions
+ stmts, err := SplitSQL(statement)
if err != nil {
return nil, err
}
@@ -55,30 +55,25 @@ func parseSnowflakeStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, ParseResult provides AST
- var statements []base.Statement
+ // Combine: Statement provides text/positions, ParseResult provides AST
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(parseResults) {
- stmt.AST = &base.ANTLRAST{
+ if !stmt.Empty && astIndex < len(parseResults) {
+ ps.AST = &base.ANTLRAST{
StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
Tree: parseResults[astIndex].Tree,
Tokens: parseResults[astIndex].Tokens,
}
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
// ParseSnowSQL parses the given SQL and returns a list of ParseResult (one per statement).
diff --git a/backend/plugin/parser/snowflake/split.go b/backend/plugin/parser/snowflake/split.go
index ad18496d95..88e01e96f7 100644
--- a/backend/plugin/parser/snowflake/split.go
+++ b/backend/plugin/parser/snowflake/split.go
@@ -13,7 +13,7 @@ func init() {
}
// SplitSQL splits the given SQL statement into multiple SQL statements using ANTLR lexer.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
lexer := parser.NewSnowflakeLexer(antlr.NewInputStream(statement))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
stream.Fill()
diff --git a/backend/plugin/parser/snowflake/split_test.go b/backend/plugin/parser/snowflake/split_test.go
index 36cfe03aab..a12282729f 100644
--- a/backend/plugin/parser/snowflake/split_test.go
+++ b/backend/plugin/parser/snowflake/split_test.go
@@ -13,7 +13,7 @@ func TestSplitSQL(t *testing.T) {
statement := `SELECT * FROM users;
SELECT * FROM orders;
SELECT * FROM products;`
- want := []base.SingleSQL{
+ want := []base.Statement{
{
Text: "SELECT * FROM users;",
BaseLine: 0,
diff --git a/backend/plugin/parser/spanner/split.go b/backend/plugin/parser/spanner/split.go
index e3cf19f4c7..b6f586b419 100644
--- a/backend/plugin/parser/spanner/split.go
+++ b/backend/plugin/parser/spanner/split.go
@@ -16,7 +16,7 @@ func init() {
// SplitSQL splits the given SQL statement into multiple SQL statements using ANTLR parser.
// This handles BEGIN/END blocks, CASE, IF, LOOP, etc. correctly.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
lexer := parser.NewGoogleSQLLexer(antlr.NewInputStream(statement))
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
@@ -48,7 +48,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
return nil, errors.New("failed to split multiple statements")
}
- var result []base.SingleSQL
+ var result []base.Statement
tokens := stream.GetAllTokens()
// Get all statement-terminating semicolons from the parse tree
@@ -89,7 +89,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
}
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : endPos+1])
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[endPos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{
diff --git a/backend/plugin/parser/spanner/split_test.go b/backend/plugin/parser/spanner/split_test.go
index 4660d3ce32..260ba442fb 100644
--- a/backend/plugin/parser/spanner/split_test.go
+++ b/backend/plugin/parser/spanner/split_test.go
@@ -13,7 +13,7 @@ func TestSplitSQL(t *testing.T) {
statement := `SELECT * FROM users;
SELECT * FROM orders;
SELECT * FROM products;`
- want := []base.SingleSQL{
+ want := []base.Statement{
{
Text: "SELECT * FROM users;",
BaseLine: 0,
diff --git a/backend/plugin/parser/standard/split.go b/backend/plugin/parser/standard/split.go
index 5e3a6c8642..756f9cd57d 100644
--- a/backend/plugin/parser/standard/split.go
+++ b/backend/plugin/parser/standard/split.go
@@ -21,10 +21,10 @@ func init() {
}
// SplitSQL splits the given SQL statement into multiple SQL statements.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
- var list []base.SingleSQL
+func SplitSQL(statement string) ([]base.Statement, error) {
+ var list []base.Statement
err := applyMultiStatements(strings.NewReader(statement), func(sql string) error {
- list = append(list, base.SingleSQL{
+ list = append(list, base.Statement{
Text: sql,
End: &storepb.Position{Line: 0, Column: 0},
Empty: false,
diff --git a/backend/plugin/parser/tidb/split.go b/backend/plugin/parser/tidb/split.go
index 8706606cca..abf0164d24 100644
--- a/backend/plugin/parser/tidb/split.go
+++ b/backend/plugin/parser/tidb/split.go
@@ -16,7 +16,7 @@ func init() {
}
// SplitSQL splits the given SQL statement into multiple SQL statements.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
t := tokenizer.NewTokenizer(statement)
list, err := t.SplitTiDBMultiSQL()
if err != nil {
@@ -67,8 +67,8 @@ func extractDelimiterStatement(stream *antlr.CommonTokenStream, pos int) (int, s
return length, stream.GetTextFromTokens(stream.Get(pos), stream.Get(length-1))
}
-func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([]base.SingleSQL, error) {
- var result []base.SingleSQL
+func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([]base.Statement, error) {
+ var result []base.Statement
delimiter := ";"
tokens := stream.GetAllTokens()
start := 0
@@ -94,7 +94,7 @@ func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : i+1])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[i]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
@@ -121,7 +121,7 @@ func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:newStart])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
// Use a single semicolon instead of the user defined delimiter.
Text: stream.GetTextFromTokens(tokens[start], tokens[i-1]) + ";",
BaseLine: tokens[start].GetLine() - 1,
@@ -148,7 +148,7 @@ func splitDelimiterModeSQL(stream *antlr.CommonTokenStream, statement string) ([
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[endPos-1]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
@@ -171,13 +171,13 @@ type openParenthesis struct {
pos int
}
-func splitTiDBStatement(stream *antlr.CommonTokenStream, statement string) ([]base.SingleSQL, error) {
+func splitTiDBStatement(stream *antlr.CommonTokenStream, statement string) ([]base.Statement, error) {
stream.Fill()
if hasDelimiterStatement(stream) {
return splitDelimiterModeSQL(stream, statement)
}
- var result []base.SingleSQL
+ var result []base.Statement
tokens := stream.GetAllTokens()
var beginCaseStack, ifStack, loopStack, whileStack, repeatStack []*openParenthesis
@@ -312,7 +312,7 @@ func splitTiDBStatement(stream *antlr.CommonTokenStream, statement string) ([]ba
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
@@ -333,7 +333,7 @@ func splitTiDBStatement(stream *antlr.CommonTokenStream, statement string) ([]ba
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start:])
// From antlr4, the line is ONE based, and the column is ZERO based.
// So we should minus 1 for the line.s
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[eofPos-1]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
diff --git a/backend/plugin/parser/tidb/tidb.go b/backend/plugin/parser/tidb/tidb.go
index 3b6ec75636..6813cfca9f 100644
--- a/backend/plugin/parser/tidb/tidb.go
+++ b/backend/plugin/parser/tidb/tidb.go
@@ -79,10 +79,10 @@ func ParseTiDBForSyntaxCheck(statement string) ([]base.AST, error) {
}
// parseTiDBStatements is the ParseStatementsFunc for TiDB.
-// Returns []Statement with both text and AST populated.
-func parseTiDBStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions
- singleSQLs, err := base.SplitMultiSQL(storepb.Engine_TIDB, statement)
+// Returns []ParsedStatement with both text and AST populated.
+func parseTiDBStatements(statement string) ([]base.ParsedStatement, error) {
+ // First split to get Statement with text and positions
+ stmts, err := base.SplitMultiSQL(storepb.Engine_TIDB, statement)
if err != nil {
return nil, err
}
@@ -93,26 +93,21 @@ func parseTiDBStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, AST provides parsed tree
- var statements []base.Statement
+ // Combine: Statement provides text/positions, AST provides parsed tree
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(asts) {
- stmt.AST = asts[astIndex]
+ if !stmt.Empty && astIndex < len(asts) {
+ ps.AST = asts[astIndex]
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
func newTiDBParser() *tidbparser.Parser {
@@ -292,7 +287,7 @@ func ExtractDelimiter(stmt string) (string, error) {
return "", errors.Errorf("cannot extract delimiter from %q", stmt)
}
-func hasDelimiter(statement string) (bool, []base.SingleSQL, error) {
+func hasDelimiter(statement string) (bool, []base.Statement, error) {
// use splitTiDBMultiSQL to check if the statement has delimiter
t := tokenizer.NewTokenizer(statement)
list, err := t.SplitTiDBMultiSQL()
diff --git a/backend/plugin/parser/tokenizer/tokenizer.go b/backend/plugin/parser/tokenizer/tokenizer.go
index 9a4dff1262..146d02ee8e 100644
--- a/backend/plugin/parser/tokenizer/tokenizer.go
+++ b/backend/plugin/parser/tokenizer/tokenizer.go
@@ -216,8 +216,8 @@ func (t *Tokenizer) aboveNonBlankLineDistance() int {
}
// SplitTiDBMultiSQL splits the statement to a string slice.
-func (t *Tokenizer) SplitTiDBMultiSQL() ([]base.SingleSQL, error) {
- var res []base.SingleSQL
+func (t *Tokenizer) SplitTiDBMultiSQL() ([]base.Statement, error) {
+ var res []base.Statement
delimiter := []rune{';'}
t.skipBlank()
@@ -230,7 +230,7 @@ func (t *Tokenizer) SplitTiDBMultiSQL() ([]base.SingleSQL, error) {
s := t.getString(startPos, t.pos()-startPos)
if !emptyString(s) {
if t.f == nil {
- res = append(res, base.SingleSQL{
+ res = append(res, base.Statement{
Text: s,
// BaseLine is 0-based line number, so subtract 1 from 1-based startLine
BaseLine: startLine - 1,
@@ -262,7 +262,7 @@ func (t *Tokenizer) SplitTiDBMultiSQL() ([]base.SingleSQL, error) {
t.skip(uint(len(delimiter)))
text := t.getString(startPos, t.pos()-startPos)
if t.f == nil {
- res = append(res, base.SingleSQL{
+ res = append(res, base.Statement{
Text: text,
// BaseLine is 0-based line number, so subtract 1 from 1-based startLine
BaseLine: startLine - 1,
@@ -288,7 +288,7 @@ func (t *Tokenizer) SplitTiDBMultiSQL() ([]base.SingleSQL, error) {
delimiter = t.runeList(delimiterStart, t.pos()-delimiterStart)
text := t.getString(startPos, t.pos()-startPos)
if t.f == nil {
- res = append(res, base.SingleSQL{
+ res = append(res, base.Statement{
Text: text,
// BaseLine is 0-based line number, so subtract 1 from 1-based startLine
BaseLine: startLine - 1,
@@ -353,8 +353,8 @@ func (t *Tokenizer) SplitTiDBMultiSQL() ([]base.SingleSQL, error) {
//
// The difference between PostgreSQL and Oracle is that PostgreSQL supports
// dollar-quoted string, but Oracle does not.
-func (t *Tokenizer) SplitStandardMultiSQL() ([]base.SingleSQL, error) {
- var res []base.SingleSQL
+func (t *Tokenizer) SplitStandardMultiSQL() ([]base.Statement, error) {
+ var res []base.Statement
t.skipBlank()
t.emptyStatement = true
@@ -387,7 +387,7 @@ func (t *Tokenizer) SplitStandardMultiSQL() ([]base.SingleSQL, error) {
t.skip(1)
text := t.getString(startPos, t.pos()-startPos)
if t.f == nil {
- res = append(res, base.SingleSQL{
+ res = append(res, base.Statement{
Text: text,
End: &store.Position{
Line: int32(t.line - 1), // Convert to 0-based.
@@ -412,7 +412,7 @@ func (t *Tokenizer) SplitStandardMultiSQL() ([]base.SingleSQL, error) {
s := t.getString(startPos, t.pos())
if !emptyString(s) {
if t.f == nil {
- res = append(res, base.SingleSQL{
+ res = append(res, base.Statement{
Text: s,
// Consider this text:
// CREATE TABLE t(
@@ -466,8 +466,8 @@ func (t *Tokenizer) SplitStandardMultiSQL() ([]base.SingleSQL, error) {
// - We support PostgreSQL CREATE PROCEDURE statement with $$ $$ style,
// but do not support BEGIN ATOMIC ... END; style.
// See https://www.postgresql.org/docs/14/sql-createprocedure.html.
-func (t *Tokenizer) SplitPostgreSQLMultiSQL() ([]base.SingleSQL, error) {
- var res []base.SingleSQL
+func (t *Tokenizer) SplitPostgreSQLMultiSQL() ([]base.Statement, error) {
+ var res []base.Statement
t.skipBlank()
t.emptyStatement = true
@@ -504,7 +504,7 @@ func (t *Tokenizer) SplitPostgreSQLMultiSQL() ([]base.SingleSQL, error) {
t.skip(1)
text := t.getString(startPos, t.pos()-startPos)
if t.f == nil {
- res = append(res, base.SingleSQL{
+ res = append(res, base.Statement{
Text: text,
// BaseLine is 0-based line number, so subtract 1 from 1-based startLine
BaseLine: startLine - 1,
@@ -523,7 +523,7 @@ func (t *Tokenizer) SplitPostgreSQLMultiSQL() ([]base.SingleSQL, error) {
s := t.getString(startPos, t.pos())
if !emptyString(s) {
if t.f == nil {
- res = append(res, base.SingleSQL{
+ res = append(res, base.Statement{
Text: s,
// BaseLine is 0-based line number, so subtract 1 from 1-based startLine
BaseLine: startLine - 1,
diff --git a/backend/plugin/parser/trino/completion.go b/backend/plugin/parser/trino/completion.go
index bf9fb563d9..47e6064867 100644
--- a/backend/plugin/parser/trino/completion.go
+++ b/backend/plugin/parser/trino/completion.go
@@ -1160,7 +1160,7 @@ func skipHeadingSQLs(statement string, caretLine int, caretOffset int) (string,
return buf.String(), newCaretLine, newCaretOffset
}
-func notEmptySQLCount(list []base.SingleSQL) int {
+func notEmptySQLCount(list []base.Statement) int {
count := 0
for _, sql := range list {
if !sql.Empty {
diff --git a/backend/plugin/parser/trino/split.go b/backend/plugin/parser/trino/split.go
index 1b93cfc313..ab5d47acb9 100644
--- a/backend/plugin/parser/trino/split.go
+++ b/backend/plugin/parser/trino/split.go
@@ -17,7 +17,7 @@ func init() {
// SplitSQL splits the given SQL statement into multiple SQL statements.
// Following TSQL's pattern, we try parser-based splitting first, then fall back to tokenizer.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
result, err := splitByParser(statement)
if err != nil {
// Fall back to tokenizer-based split
@@ -26,7 +26,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
return result, nil
}
-func splitByTokenizer(statement string) ([]base.SingleSQL, error) {
+func splitByTokenizer(statement string) ([]base.Statement, error) {
t := tokenizer.NewTokenizer(statement)
list, err := t.SplitStandardMultiSQL()
if err != nil {
@@ -100,7 +100,7 @@ func splitByTokenizer(statement string) ([]base.SingleSQL, error) {
return list, nil
}
-func splitByParser(statement string) ([]base.SingleSQL, error) {
+func splitByParser(statement string) ([]base.Statement, error) {
input := antlr.NewInputStream(statement)
lexer := trinoparser.NewTrinoLexer(input)
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
@@ -130,7 +130,7 @@ func splitByParser(statement string) ([]base.SingleSQL, error) {
return nil, parserErrorListener.Err
}
- var result []base.SingleSQL
+ var result []base.Statement
tokens := stream.GetAllTokens()
// Walk through all statements
@@ -188,7 +188,7 @@ func splitByParser(statement string) ([]base.SingleSQL, error) {
endLine := endToken.GetLine() - 1
endColumn := endToken.GetColumn() + len(endToken.GetText())
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: text,
BaseLine: firstToken.GetLine() - 1,
Start: &storepb.Position{
diff --git a/backend/plugin/parser/trino/split_test.go b/backend/plugin/parser/trino/split_test.go
index 166db1744d..26984263e5 100644
--- a/backend/plugin/parser/trino/split_test.go
+++ b/backend/plugin/parser/trino/split_test.go
@@ -15,14 +15,14 @@ type splitTestData struct {
}
type resData struct {
- res []base.SingleSQL
+ res []base.Statement
err string
}
// MockSplitSQL is a simplified implementation for testing
-func MockSplitSQL(_ string) ([]base.SingleSQL, error) {
+func MockSplitSQL(_ string) ([]base.Statement, error) {
// This is just for testing and isn't used since the real implementation exists in split.go
- return []base.SingleSQL{}, nil
+ return []base.Statement{}, nil
}
func TestTrinoSplitMultiSQL(t *testing.T) {
@@ -31,7 +31,7 @@ func TestTrinoSplitMultiSQL(t *testing.T) {
{
statement: "SELECT * FROM users; SELECT * FROM orders;",
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "SELECT * FROM users;",
Start: &storepb.Position{Line: 0, Column: 0},
@@ -59,7 +59,7 @@ func TestTrinoSplitMultiSQL(t *testing.T) {
comment */
SELECT * FROM orders;`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `SELECT
id,
@@ -89,7 +89,7 @@ func TestTrinoSplitMultiSQL(t *testing.T) {
SELECT * FROM products;`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: `WITH orders_cte AS (
SELECT * FROM orders
diff --git a/backend/plugin/parser/tsql/completion.go b/backend/plugin/parser/tsql/completion.go
index 171eca20c7..71eb8e41b8 100644
--- a/backend/plugin/parser/tsql/completion.go
+++ b/backend/plugin/parser/tsql/completion.go
@@ -1286,7 +1286,7 @@ func skipHeadingSQLs(statement string, caretLine int, caretOffset int) (string,
return buf.String(), newCaretLine, newCaretOffset
}
-func notEmptySQLCount(list []base.SingleSQL) int {
+func notEmptySQLCount(list []base.Statement) int {
count := 0
for _, sql := range list {
if !sql.Empty {
diff --git a/backend/plugin/parser/tsql/restore.go b/backend/plugin/parser/tsql/restore.go
index 811c2b8d6c..8a3568ddb3 100644
--- a/backend/plugin/parser/tsql/restore.go
+++ b/backend/plugin/parser/tsql/restore.go
@@ -25,7 +25,7 @@ func init() {
}
func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
- originalSQL, err := extractSingleSQL(statement, backupItem)
+ originalSQL, err := extractStatement(statement, backupItem)
if err != nil {
return "", errors.Errorf("failed to extract single SQL: %v", err)
}
@@ -367,7 +367,7 @@ func (l *updateElemListener) EnterUpdate_elem(ctx *parser.Update_elemContext) {
}
}
-func extractSingleSQL(statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
+func extractStatement(statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
if backupItem == nil {
return "", errors.Errorf("backup item is nil")
}
diff --git a/backend/plugin/parser/tsql/split.go b/backend/plugin/parser/tsql/split.go
index d44838e037..c2f0e5cd04 100644
--- a/backend/plugin/parser/tsql/split.go
+++ b/backend/plugin/parser/tsql/split.go
@@ -15,7 +15,7 @@ func init() {
}
// SplitSQL splits the given SQL statement into multiple SQL statements.
-func SplitSQL(statement string) ([]base.SingleSQL, error) {
+func SplitSQL(statement string) ([]base.Statement, error) {
r, err := splitByParser(statement)
if err != nil {
// Fall back to semi split.
@@ -24,7 +24,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {
return r, err
}
-func splitBySemi(statement string) ([]base.SingleSQL, error) {
+func splitBySemi(statement string) ([]base.Statement, error) {
t := tokenizer.NewTokenizer(statement)
list, err := t.SplitStandardMultiSQL()
if err != nil {
@@ -33,7 +33,7 @@ func splitBySemi(statement string) ([]base.SingleSQL, error) {
return list, nil
}
-func splitByParser(statement string) ([]base.SingleSQL, error) {
+func splitByParser(statement string) ([]base.Statement, error) {
inputStream := antlr.NewInputStream(statement)
lexer := parser.NewTSqlLexer(inputStream)
stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
@@ -64,7 +64,7 @@ func splitByParser(statement string) ([]base.SingleSQL, error) {
return nil, parserErrorListener.Err
}
- var result []base.SingleSQL
+ var result []base.Statement
tokens := stream.GetAllTokens()
start := 0
@@ -73,7 +73,7 @@ func splitByParser(statement string) ([]base.SingleSQL, error) {
for _, goStmt := range tree.AllGo_statement() {
pos := goStmt.GetStop().GetTokenIndex()
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
@@ -93,7 +93,7 @@ func splitByParser(statement string) ([]base.SingleSQL, error) {
// First batch_without_go.
b := tree.AllBatch_without_go()[0]
- var r []base.SingleSQL
+ var r []base.Statement
r, start = splitBatchWithoutGo(b, tokens, stream, start, statement)
result = append(result, r...)
@@ -115,7 +115,7 @@ func splitByParser(statement string) ([]base.SingleSQL, error) {
for _, goStmt := range goStmts {
pos := goStmt.GetStop().GetTokenIndex()
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
@@ -141,7 +141,7 @@ func splitByParser(statement string) ([]base.SingleSQL, error) {
for _, goStmt := range tree.AllGo_statement()[goIdx:] {
pos := goStmt.GetStop().GetTokenIndex()
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
@@ -161,15 +161,15 @@ func splitByParser(statement string) ([]base.SingleSQL, error) {
return result, nil
}
-func splitBatchWithoutGo(b parser.IBatch_without_goContext, tokens []antlr.Token, stream *antlr.CommonTokenStream, start int, statement string) ([]base.SingleSQL, int) {
- var result []base.SingleSQL
+func splitBatchWithoutGo(b parser.IBatch_without_goContext, tokens []antlr.Token, stream *antlr.CommonTokenStream, start int, statement string) ([]base.Statement, int) {
+ var result []base.Statement
switch {
case b.Batch_level_statement() == nil && b.Execute_body_batch() == nil:
// All sql_clauses.
for _, sqlClause := range b.AllSql_clauses() {
pos := sqlClause.GetStop().GetTokenIndex()
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
@@ -187,7 +187,7 @@ func splitBatchWithoutGo(b parser.IBatch_without_goContext, tokens []antlr.Token
case b.Batch_level_statement() != nil:
pos := b.Batch_level_statement().GetStop().GetTokenIndex()
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
@@ -204,7 +204,7 @@ func splitBatchWithoutGo(b parser.IBatch_without_goContext, tokens []antlr.Token
case b.Execute_body_batch() != nil:
pos := b.Execute_body_batch().GetStop().GetTokenIndex()
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
@@ -221,7 +221,7 @@ func splitBatchWithoutGo(b parser.IBatch_without_goContext, tokens []antlr.Token
for _, sqlClause := range b.AllSql_clauses() {
pos := sqlClause.GetStop().GetTokenIndex()
antlrPosition := base.FirstDefaultChannelTokenPosition(tokens[start : pos+1])
- result = append(result, base.SingleSQL{
+ result = append(result, base.Statement{
Text: stream.GetTextFromTokens(tokens[start], tokens[pos]),
BaseLine: tokens[start].GetLine() - 1,
End: common.ConvertANTLRPositionToPosition(
diff --git a/backend/plugin/parser/tsql/split_test.go b/backend/plugin/parser/tsql/split_test.go
index 3b4eeb80ca..9a4028ac14 100644
--- a/backend/plugin/parser/tsql/split_test.go
+++ b/backend/plugin/parser/tsql/split_test.go
@@ -15,7 +15,7 @@ type splitTestData struct {
}
type resData struct {
- res []base.SingleSQL
+ res []base.Statement
err string
}
@@ -36,7 +36,7 @@ go
go
`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "-- first statement\ndeclare @temp table(a int)",
BaseLine: 0,
@@ -96,7 +96,7 @@ UPDATE SalesLT.ProductModelProductDescription SET Culture = "zh-cn";
`,
want: resData{
- res: []base.SingleSQL{
+ res: []base.Statement{
{
Text: "\n\n\n\n\n\n\n\n\nUPDATE SalesLT.Address SET City = \"Shanghai\";",
BaseLine: 0,
diff --git a/backend/plugin/parser/tsql/tsql.go b/backend/plugin/parser/tsql/tsql.go
index 024859e378..9b606d0d4a 100644
--- a/backend/plugin/parser/tsql/tsql.go
+++ b/backend/plugin/parser/tsql/tsql.go
@@ -43,10 +43,10 @@ func toAST(results []*base.ParseResult) []base.AST {
}
// parseTSQLStatements is the ParseStatementsFunc for T-SQL (MSSQL).
-// Returns []Statement with both text and AST populated.
-func parseTSQLStatements(statement string) ([]base.Statement, error) {
- // First split to get SingleSQL with text and positions
- singleSQLs, err := SplitSQL(statement)
+// Returns []ParsedStatement with both text and AST populated.
+func parseTSQLStatements(statement string) ([]base.ParsedStatement, error) {
+ // First split to get Statement with text and positions
+ stmts, err := SplitSQL(statement)
if err != nil {
return nil, err
}
@@ -57,30 +57,25 @@ func parseTSQLStatements(statement string) ([]base.Statement, error) {
return nil, err
}
- // Combine: SingleSQL provides text/positions, ParseResult provides AST
- var statements []base.Statement
+ // Combine: Statement provides text/positions, ParseResult provides AST
+ var result []base.ParsedStatement
astIndex := 0
- for _, sql := range singleSQLs {
- stmt := base.Statement{
- Text: sql.Text,
- Empty: sql.Empty,
- StartPosition: sql.Start,
- EndPosition: sql.End,
- ByteOffsetStart: sql.ByteOffsetStart,
- ByteOffsetEnd: sql.ByteOffsetEnd,
+ for _, stmt := range stmts {
+ ps := base.ParsedStatement{
+ Statement: stmt,
}
- if !sql.Empty && astIndex < len(parseResults) {
- stmt.AST = &base.ANTLRAST{
+ if !stmt.Empty && astIndex < len(parseResults) {
+ ps.AST = &base.ANTLRAST{
StartPosition: &storepb.Position{Line: int32(parseResults[astIndex].BaseLine) + 1},
Tree: parseResults[astIndex].Tree,
Tokens: parseResults[astIndex].Tokens,
}
astIndex++
}
- statements = append(statements, stmt)
+ result = append(result, ps)
}
- return statements, nil
+ return result, nil
}
// ParseTSQL parses the given SQL and returns a list of ParseResult (one per statement).