Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
fix(mssql): match each query result to its statement (#21481)
Danny Xuf4e2d289aba4
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.goindex 5d0ca99a4d..cf15533e3a 100644--- a/backend/api/v1/sql_service.go+++ b/backend/api/v1/sql_service.go@@ -732,6 +732,7 @@ func queryRetry(maskingEnabled := !queryContext.Explain && !queryContext.SkipMasking &&licenseService.IsFeatureEnabledForInstance(ctx, common.GetWorkspaceIDFromContext(ctx), v1pb.PlanFeature_FEATURE_DATA_MASKING, instance) == nil+ queryContext.MaskingEnabled = maskingEnabledif maskingEnabled {if err := preExecuteMaskingCheck(ctx, stores, instance.Metadata.GetEngine(), database, spans); err != nil {diff --git a/backend/plugin/db/driver.go b/backend/plugin/db/driver.goindex d5f03a0f59..e58f2320fe 100644--- a/backend/plugin/db/driver.go+++ b/backend/plugin/db/driver.go@@ -131,6 +131,10 @@ type QueryContext struct {Option *v1pb.QueryOption// SkipMasking skips data masking when the query is authorized by an access grant with unmask=true.SkipMasking bool+ // MaskingEnabled means the results will be masked. Masking finds the columns to mask+ // from the statement, so a driver must withhold rows the statement does not trace+ // to columns, such as those a procedure call returns.+ MaskingEnabled bool// The maximum number of bytes for sql results in response body.MaximumSQLResultSize int64Timeout *durationpb.Durationdiff --git a/backend/plugin/db/mssql/mssql.go b/backend/plugin/db/mssql/mssql.goindex df34b28b68..b48dec4cc4 100644--- a/backend/plugin/db/mssql/mssql.go+++ b/backend/plugin/db/mssql/mssql.go@@ -9,6 +9,7 @@ import ("log/slog""net/url""os"+ "slices""strings""time"@@ -378,7 +379,9 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string// Regular query processing (unchanged)batch := tsqlbatch.NewBatcher(statement)- var results []*v1pb.QueryResult+ // Callers pair results[i] with the request's i-th statement, so the further+ // result sets of procedure calls come after every statement's result.+ var results, procedureResults []*v1pb.QueryResultfor {command, err := batch.Next()if err != nil {@@ -386,8 +389,9 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement stringv := batch.Batch()if v != nil && len(v.Text) > 0 {// Query the last batch.- qr, err := d.queryBatch(ctx, conn, v.Text, queryContext)+ qr, more, err := d.queryBatch(ctx, conn, v.Text, queryContext)results = append(results, qr...)+ procedureResults = append(procedureResults, more...)if err != nil {return results, err}@@ -404,8 +408,9 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement stringcase *tsqlbatch.GoCommand:b := batch.Batch()// Query the batch.- qr, err := d.queryBatch(ctx, conn, b.Text, queryContext)+ qr, more, err := d.queryBatch(ctx, conn, b.Text, queryContext)results = append(results, qr...)+ procedureResults = append(procedureResults, more...)if err != nil {return results, err}@@ -414,7 +419,7 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string}batch.Reset(nil)}- return results, nil+ return append(results, procedureResults...), nil}// showplanStatistic picks the SET statement that turns on the requested explain@@ -428,17 +433,18 @@ func showplanStatistic(option *v1pb.QueryOption) string {return "SHOWPLAN_ALL"}-// queryBatch queries a batch of SQL statements, for Result Set-Generating statements, it returns the results, for Row Count-Generating statements,-// it returns the affected rows, for other statements, it returns the empty query result.+// queryBatch queries a batch of SQL statements and returns one result for each: the result set of a Result Set-Generating+// statement, the affected rows of a Row Count-Generating statement, or an empty result. The second slice holds a procedure+// call's result sets after its first.// https://learn.microsoft.com/en-us/sql/odbc/reference/develop-app/result-generating-and-result-free-statements?view=sql-server-ver16-func (*Driver) queryBatch(ctx context.Context, conn *sql.Conn, batch string, queryContext db.QueryContext) ([]*v1pb.QueryResult, error) {+func (*Driver) queryBatch(ctx context.Context, conn *sql.Conn, batch string, queryContext db.QueryContext) ([]*v1pb.QueryResult, []*v1pb.QueryResult, error) {singleSQLs, err := tsqlparser.SplitSQL(batch)if err != nil {- return nil, err+ return nil, nil, err}singleSQLs = base.FilterEmptyStatements(singleSQLs)if len(singleSQLs) == 0 {- return nil, nil+ return nil, nil, nil}// Special handling for EXPLAIN queries in MSSQL using explain@@ -446,7 +452,7 @@ func (*Driver) queryBatch(ctx context.Context, conn *sql.Conn, batch string, queexplain := showplanStatistic(queryContext.Option)// Enable explain mode once for all statementsif _, err := conn.ExecContext(ctx, fmt.Sprintf("SET %s ON", explain)); err != nil { // NOSONAR(go:S2077) explain is a hardcoded constant ("SHOWPLAN_ALL" or "SHOWPLAN_XML"), not user input- return nil, errors.Wrap(err, "failed to enable explain mode")+ return nil, nil, errors.Wrap(err, "failed to enable explain mode")}// Ensure explain is turned off after processingdefer func() {@@ -500,7 +506,7 @@ func (*Driver) queryBatch(ctx context.Context, conn *sql.Conn, batch string, que}}- return results, nil+ return results, nil, nil}// Regular query processing for non-EXPLAIN queries@@ -511,7 +517,7 @@ func (*Driver) queryBatch(ctx context.Context, conn *sql.Conn, batch string, quefor _, singleSQL := range singleSQLs {stmtType, err := getStmtType(singleSQL.Text)if err != nil {- return nil, err+ return nil, nil, err}stmtTypes = append(stmtTypes, stmtType)// Before sending the batch to server, we add the limit clause to the statement.@@ -521,10 +527,10 @@ func (*Driver) queryBatch(ctx context.Context, conn *sql.Conn, batch string, que}refinedSQLs = append(refinedSQLs, s)if _, err := batchBuf.WriteString(s); err != nil {- return nil, err+ return nil, nil, err}if _, err := batchBuf.WriteString("\n"); err != nil {- return nil, err+ return nil, nil, err}}@@ -532,22 +538,17 @@ func (*Driver) queryBatch(ctx context.Context, conn *sql.Conn, batch string, queretmsg := &sqlexp.ReturnMessage{}rows, qe := conn.QueryContext(ctx, refinedBatch, retmsg) // NOSONAR(go:S2077) intentional execution of user-authored SQL in SQL Editorif qe != nil {- return nil, qe+ return nil, nil, qe}defer rows.Close()- nextResultSetIdx := getNextResultSetIdx(stmtTypes, 0)- nextAffectedRowsIdx := getNextAffectedRowsIdx(stmtTypes, 0)- skipRowsAffected := false- results := true- var ret []*v1pb.QueryResult- for results {- queryResult := new(v1pb.QueryResult)- msg := retmsg.Message(ctx)- // While meeting the RowsAffected and MsgNext, fill up the lap for the other statement types.- switch m := msg.(type) {+ var resultSets []*v1pb.QueryResult+ var rowCounts []int64+ inResultSet := false+ for more := true; more; {+ switch m := retmsg.Message(ctx).(type) {case sqlexp.MsgNotice:if err := isExitError(err); err != nil {- return ret, err+ return nil, nil, err}case sqlexp.MsgError:err := m.Error@@ -555,61 +556,130 @@ func (*Driver) queryBatch(ctx context.Context, conn *sql.Conn, batch string, queif errors.As(err, &e) {err = unpackGoMSSQLDBError(e)}- queryResult.Error = err.Error()- ret = append(ret, queryResult)- return ret, err+ return nil, nil, errcase sqlexp.MsgRowsAffected:- // Assuming the rows affected appears after the MsgNext for SELECT statement, and ignore the MsgRowsAffected- // for SELECT statement for now.- if skipRowsAffected {- skipRowsAffected = false- nextAffectedRowsIdx = getNextAffectedRowsIdx(stmtTypes, nextAffectedRowsIdx+1)- continue- }- queryResult = util.BuildAffectedRowsResult(m.Count, nil)- emptyResultSets := make([]*v1pb.QueryResult, nextAffectedRowsIdx-len(ret))- for i := 0; i < len(emptyResultSets); i++ {- emptyResultSets[i] = &v1pb.QueryResult{}+ // The count that closes a result set is the result set's own row count.+ if !inResultSet {+ rowCounts = append(rowCounts, m.Count)}- ret = append(ret, emptyResultSets...)- ret = append(ret, queryResult)- nextAffectedRowsIdx = getNextAffectedRowsIdx(stmtTypes, nextAffectedRowsIdx+1)case sqlexp.MsgNextResultSet:- results = rows.NextResultSet()+ inResultSet = false+ more = rows.NextResultSet()if err = rows.Err(); err != nil {- return ret, err+ return nil, nil, err}case sqlexp.MsgNext:- r, err := util.RowsToQueryResult(rows, makeValueByTypeName, convertValue, queryContext.MaximumSQLResultSize)+ result, err := readResultSet(rows, queryContext)if err != nil {- queryResult.Error = err.Error()- ret = append(ret, queryResult)- return ret, err- }- if err := rows.Err(); err != nil {- return ret, err+ return nil, nil, err}- queryResult = r- // Fill up the lap for the other statement types.- emptyResultSets := make([]*v1pb.QueryResult, nextResultSetIdx-len(ret))- for i := 0; i < len(emptyResultSets); i++ {- emptyResultSets[i] = &v1pb.QueryResult{}- }- ret = append(ret, emptyResultSets...)- ret = append(ret, queryResult)- nextResultSetIdx = getNextResultSetIdx(stmtTypes, nextResultSetIdx+1)- skipRowsAffected = true+ resultSets = append(resultSets, result)+ inResultSet = truedefault:}}+ results, procedureResults, err := matchResults(refinedSQLs, stmtTypes, resultSets, rowCounts)+ if err != nil {+ return nil, nil, err+ }+ if queryContext.MaskingEnabled {+ for i, t := range stmtTypes {+ if t&(stmtTypeProcedure|stmtTypeOutput) != 0 {+ withholdRows(results[i])+ }+ }+ for _, result := range procedureResults {+ withholdRows(result)+ }+ }latency := time.Since(startTime)- for i, res := range ret {+ for _, res := range slices.Concat(results, procedureResults) {res.Latency = durationpb.New(latency)- res.Statement = refinedSQLs[i]}+ return results, procedureResults, nil+}- return ret, nil+// readResultSet reads the current result set. The limit rewrite covers only SELECT,+// so the row limit is applied here as well, for the rows of a procedure call or an+// OUTPUT clause.+func readResultSet(rows *sql.Rows, queryContext db.QueryContext) (*v1pb.QueryResult, error) {+ result, err := util.RowsToLimitedQueryResult(rows, makeValueByTypeName, convertValue, queryContext.MaximumSQLResultSize, queryContext.Limit)+ if err != nil {+ return nil, err+ }+ if result.Error != "" {+ // The read stopped at the size limit, and the next message only arrives+ // once the rest of the result set has been read. Past the end of a result+ // set, Next would read the following one.+ for rows.Next() {+ }+ if err := rows.Err(); err != nil {+ return nil, err+ }+ }+ return result, nil+}++// withholdRows empties a result set of a procedure call or an OUTPUT clause,+// whose rows masking cannot trace to columns.+func withholdRows(result *v1pb.QueryResult) {+ if len(result.ColumnNames) == 0 {+ return+ }+ result.Rows = nil+ result.RowsCount = 0+ result.Error = "Rows returned by a procedure call or an OUTPUT clause are hidden because data masking can't be applied to them."+}++// matchResults gives each statement of a batch its result. SQL Server returns+// results in statement order but does not say which statement returned each, so+// a batch whose procedure call returns result sets must have no other statement+// that returns any. The procedure call's result sets after its first are+// returned separately.+func matchResults(statements []string, types []stmtType, resultSets []*v1pb.QueryResult, rowCounts []int64) ([]*v1pb.QueryResult, []*v1pb.QueryResult, error) {+ var withResultSet, withRowCount, procedures int+ for _, t := range types {+ switch {+ case t&stmtTypeResultSetGenerating != 0:+ withResultSet+++ case t&stmtTypeRowCountGenerating != 0:+ withRowCount+++ case t&stmtTypeProcedure != 0:+ procedures+++ default:+ }+ }+ procedureReturnedSets := len(resultSets) != withResultSet+ if procedureReturnedSets && (withResultSet > 0 || procedures != 1) {+ return nil, nil, errors.New("cannot match the batch's result sets to its statements; a procedure call that returns rows must be the only statement in its batch that does, so separate the others with GO")+ }+ // SET NOCOUNT and procedure calls change how many row counts arrive, so the+ // counts are shown only when each belongs to one statement.+ if len(rowCounts) != withRowCount {+ rowCounts = nil+ }++ results := make([]*v1pb.QueryResult, len(types))+ var procedureResults []*v1pb.QueryResult+ for i, t := range types {+ result := &v1pb.QueryResult{}+ switch {+ case t&stmtTypeResultSetGenerating != 0:+ result, resultSets = resultSets[0], resultSets[1:]+ case t&stmtTypeRowCountGenerating != 0 && len(rowCounts) > 0:+ result, rowCounts = util.BuildAffectedRowsResult(rowCounts[0], nil), rowCounts[1:]+ case t&stmtTypeProcedure != 0 && procedureReturnedSets:+ result, procedureResults = resultSets[0], resultSets[1:]+ for _, r := range procedureResults {+ r.Statement = statements[i]+ }+ default:+ }+ result.Statement = statements[i]+ results[i] = result+ }+ return results, procedureResults, nil}func isExitError(err error) error {@@ -628,21 +698,3 @@ func isExitError(err error) error {}return nil}--func getNextAffectedRowsIdx(s []stmtType, beginIdx int) int {- for i := beginIdx; i < len(s); i++ {- if s[i]&stmtTypeRowCountGenerating != 0 {- return i- }- }- return len(s)-}--func getNextResultSetIdx(s []stmtType, beginIdx int) int {- for i := beginIdx; i < len(s); i++ {- if s[i]&stmtTypeResultSetGenerating != 0 {- return i- }- }- return len(s)-}diff --git a/backend/plugin/db/mssql/mssql_test.go b/backend/plugin/db/mssql/mssql_test.goindex 93a2a32474..4634197668 100644--- a/backend/plugin/db/mssql/mssql_test.go+++ b/backend/plugin/db/mssql/mssql_test.go@@ -2,7 +2,10 @@ package mssqlimport ("context"+ "fmt"+ "strings""testing"+ "time""github.com/stretchr/testify/require"@@ -57,3 +60,189 @@ func TestQueryConnRecordsLimitedStatement(t *testing.T) {require.Equal(t, "\nSELECT TOP 2 id FROM dbo.t ORDER BY id;", results[1].GetStatement())require.Len(t, results[1].GetRows(), 2)}++func TestQueryConnMatchesResultsToStatements(t *testing.T) {+ t.Parallel()+ ctx := context.Background()+ driver := newSyncTestDatabase(ctx, t, testcontainer.SharedMSSQLContainer(t))+ executeBatches(ctx, t, driver, `CREATE TABLE dbo.t (id INT PRIMARY KEY);+INSERT INTO dbo.t VALUES (1), (2), (3);+GO+CREATE PROCEDURE dbo.two_sets AS+BEGIN+ UPDATE dbo.t SET id = id;+ SELECT id FROM dbo.t ORDER BY id;+ SELECT 'second' AS s;+END`)++ conn, err := driver.GetDB().Conn(ctx)+ require.NoError(t, err)+ defer conn.Close()+ queryContext := db.QueryContext{MaximumSQLResultSize: 1 << 30}+ describe := func(results []*v1pb.QueryResult) []string {+ var got []string+ for _, r := range results {+ line := fmt.Sprintf("%s %v %d", strings.TrimSpace(r.GetStatement()), r.GetColumnNames(), len(r.GetRows()))+ if r.GetError() != "" {+ line += " error"+ }+ got = append(got, line)+ }+ return got+ }++ // Statements that return nothing keep their places across GO, and the+ // procedure's second result set comes after every statement's result.+ results, err := driver.QueryConn(ctx, conn, `EXEC dbo.two_sets;+DECLARE @x INT;+SELECT @x = id FROM dbo.t;+GO+DECLARE @y INT;+SELECT @y = id FROM dbo.t;+SELECT id FROM dbo.t WHERE id = 3;`, queryContext)+ require.NoError(t, err)+ require.Equal(t, []string{+ "EXEC dbo.two_sets; [id] 3",+ "DECLARE @x INT; [] 0",+ "SELECT @x = id FROM dbo.t; [] 0",+ "DECLARE @y INT; [] 0",+ "SELECT @y = id FROM dbo.t; [] 0",+ "SELECT id FROM dbo.t WHERE id = 3; [id] 1",+ "EXEC dbo.two_sets; [s] 1",+ }, describe(results))++ results, err = driver.QueryConn(ctx, conn, "EXEC dbo.two_sets;", db.QueryContext{Limit: 2, MaximumSQLResultSize: 1 << 30})+ require.NoError(t, err)+ require.Equal(t, []string{"EXEC dbo.two_sets; [id] 2", "EXEC dbo.two_sets; [s] 1"}, describe(results))++ // The size limit covers the rows kept, not the ones the row limit cuts.+ results, err = driver.QueryConn(ctx, conn, "EXEC('SELECT TOP 200 name FROM sys.all_objects');", db.QueryContext{Limit: 2, MaximumSQLResultSize: 2000})+ require.NoError(t, err)+ require.Len(t, results, 1)+ require.Empty(t, results[0].GetError())+ require.Len(t, results[0].GetRows(), 2)++ // Masking cannot trace the rows of a procedure call or an OUTPUT clause.+ results, err = driver.QueryConn(ctx, conn, "EXEC dbo.two_sets;\nGO\nUPDATE dbo.t SET id = id OUTPUT inserted.id;\nSELECT id FROM dbo.t WHERE id = 1;", db.QueryContext{MaskingEnabled: true, MaximumSQLResultSize: 1 << 30})+ require.NoError(t, err)+ require.Equal(t, []string{+ "EXEC dbo.two_sets; [id] 0 error",+ "UPDATE dbo.t SET id = id OUTPUT inserted.id; [id] 0 error",+ "SELECT id FROM dbo.t WHERE id = 1; [id] 1",+ "EXEC dbo.two_sets; [s] 0 error",+ }, describe(results))+ require.Contains(t, results[0].GetError(), "data masking")++ _, err = driver.QueryConn(ctx, conn, "EXEC dbo.two_sets;\nSELECT 1 AS one;", queryContext)+ require.ErrorContains(t, err, "cannot match the batch's result sets to its statements")++ _, err = driver.QueryConn(ctx, conn, "SET NOEXEC ON;\nSELECT 1 AS one;", queryContext)+ require.EqualError(t, err, "SET NOEXEC is not supported")++ _, err = driver.QueryConn(ctx, conn, "SELECT 1 AS one;\nSELECT 1/0 AS x;", queryContext)+ require.ErrorContains(t, err, "Divide by zero error encountered")++ // A result set cut off at the size limit must not stall the rest of the batch.+ timeoutCtx, cancel := context.WithTimeout(ctx, 30*time.Second)+ defer cancel()+ results, err = driver.QueryConn(timeoutCtx, conn, "SELECT TOP 100 name FROM sys.all_objects;\nSELECT 1 AS one;", db.QueryContext{MaximumSQLResultSize: 1})+ require.NoError(t, err)+ require.Len(t, results, 2)+ require.Contains(t, results[0].GetError(), "exceeds max allowed output size")+ require.Len(t, results[1].GetRows(), 1)+}++func TestMatchResults(t *testing.T) {+ const (+ rows = stmtTypeResultSetGenerating | stmtTypeRowCountGenerating+ count = stmtTypeRowCountGenerating+ none = stmtTypeUnknown+ proc = stmtTypeProcedure+ )+ // describe names a result by its column, or by its affected rows.+ describe := func(results []*v1pb.QueryResult) []string {+ var got []string+ for _, r := range results {+ name := strings.Join(r.GetColumnNames(), ",")+ if name == "Affected Rows" {+ name = fmt.Sprintf("affected %d", r.GetRows()[0].GetValues()[0].GetInt64Value())+ }+ got = append(got, r.GetStatement()+":"+name)+ }+ return got+ }+ for _, tc := range []struct {+ name string+ types []stmtType+ sets []string+ counts []int64+ want []string+ wantExtra []string+ wantErr bool+ }{+ {+ name: "each statement gets its own result",+ types: []stmtType{none, rows, count, rows},+ sets: []string{"a", "b"},+ counts: []int64{3},+ want: []string{"s0:", "s1:a", "s2:affected 3", "s3:b"},+ },+ {+ name: "a procedure call takes every result set",+ types: []stmtType{none, proc, count},+ sets: []string{"a", "b", "c"},+ counts: []int64{4},+ want: []string{"s0:", "s1:a", "s2:affected 4"},+ wantExtra: []string{"s1:b", "s1:c"},+ },+ {+ name: "a procedure call that returns nothing",+ types: []stmtType{proc, rows},+ sets: []string{"a"},+ want: []string{"s0:", "s1:a"},+ },+ {+ name: "row counts that cannot be told apart are dropped",+ types: []stmtType{count, proc, count},+ counts: []int64{1, 2, 3},+ want: []string{"s0:", "s1:", "s2:"},+ },+ {+ name: "a procedure call beside another statement that returns rows",+ types: []stmtType{proc, rows},+ sets: []string{"a", "b"},+ wantErr: true,+ },+ {+ name: "two procedure calls",+ types: []stmtType{proc, proc},+ sets: []string{"a"},+ wantErr: true,+ },+ {+ name: "a statement without its result set",+ types: []stmtType{rows, rows},+ sets: []string{"a"},+ wantErr: true,+ },+ } {+ t.Run(tc.name, func(t *testing.T) {+ statements := make([]string, len(tc.types))+ for i := range statements {+ statements[i] = fmt.Sprintf("s%d", i)+ }+ var sets []*v1pb.QueryResult+ for _, column := range tc.sets {+ sets = append(sets, &v1pb.QueryResult{ColumnNames: []string{column}})+ }+ results, extra, err := matchResults(statements, tc.types, sets, tc.counts)+ if tc.wantErr {+ require.Error(t, err)+ return+ }+ require.NoError(t, err)+ require.Equal(t, tc.want, describe(results))+ require.Equal(t, tc.wantExtra, describe(extra))+ })+ }+}diff --git a/backend/plugin/db/mssql/stmt_type.go b/backend/plugin/db/mssql/stmt_type.goindex 37b9653799..4eedd8a169 100644--- a/backend/plugin/db/mssql/stmt_type.go+++ b/backend/plugin/db/mssql/stmt_type.go@@ -1,6 +1,8 @@package mssqlimport (+ "strings"+"github.com/bytebase/omni/mssql/ast""github.com/pkg/errors"@@ -11,8 +13,13 @@ type stmtType = intconst (stmtTypeUnknown = 1 << iota+ // stmtTypeResultSetGenerating returns exactly one result set.stmtTypeResultSetGeneratingstmtTypeRowCountGenerating+ // stmtTypeProcedure returns any number of result sets and row counts.+ stmtTypeProcedure+ // stmtTypeOutput is a data modification whose OUTPUT clause returns rows.+ stmtTypeOutput)func getStmtType(stmt string) (stmtType, error) {@@ -46,14 +53,37 @@ func classifyStmtType(node ast.Node) (stmtType, error) {// SELECT ... INTO materialises a new table — no result set, only row count.return stmtTypeRowCountGenerating, nil}+ if assignsVariables(n) {+ // SELECT @v = ... returns no result set or row count.+ return stmtTypeUnknown, nil+ }return stmtTypeResultSetGenerating | stmtTypeRowCountGenerating, nil- case *ast.InsertStmt, *ast.UpdateStmt, *ast.DeleteStmt, *ast.MergeStmt,- *ast.BulkInsertStmt, *ast.InsertBulkStmt, *ast.CopyIntoStmt,+ case *ast.InsertStmt:+ return dmlStmtType(n.OutputClause), nil+ case *ast.UpdateStmt:+ return dmlStmtType(n.OutputClause), nil+ case *ast.DeleteStmt:+ return dmlStmtType(n.OutputClause), nil+ case *ast.MergeStmt:+ return dmlStmtType(n.OutputClause), nil++ case *ast.BulkInsertStmt, *ast.InsertBulkStmt, *ast.CopyIntoStmt,*ast.ReadtextStmt, *ast.WritetextStmt, *ast.UpdatetextStmt,*ast.ReceiveStmt, *ast.PredictStmt:return stmtTypeRowCountGenerating, nil+ case *ast.ExecStmt:+ return stmtTypeProcedure, nil++ case *ast.SetOptionStmt:+ if strings.EqualFold(n.Option, "NOEXEC") || strings.EqualFold(n.Option, "PARSEONLY") {+ // These skip statements without an error, so the result sets that do+ // arrive could not be matched to their statements.+ return stmtTypeUnknown, errors.Errorf("SET %s is not supported", strings.ToUpper(n.Option))+ }+ return stmtTypeUnknown, nil+case *ast.IfStmt, *ast.WhileStmt, *ast.BeginEndStmt, *ast.TryCatchStmt,*ast.ReturnStmt, *ast.BreakStmt, *ast.ContinueStmt, *ast.GotoStmt,*ast.LabelStmt, *ast.WaitForStmt:@@ -63,3 +93,26 @@ func classifyStmtType(node ast.Node) (stmtType, error) {return stmtTypeUnknown, nil}}++// dmlStmtType classifies a data modification, which also returns the affected+// rows as a result set when its OUTPUT clause has no INTO.+func dmlStmtType(output *ast.OutputClause) stmtType {+ if output != nil && output.IntoTable == nil {+ return stmtTypeResultSetGenerating | stmtTypeRowCountGenerating | stmtTypeOutput+ }+ return stmtTypeRowCountGenerating+}++func assignsVariables(sel *ast.SelectStmt) bool {+ if sel.TargetList == nil {+ return false+ }+ for _, item := range sel.TargetList.Items {+ if target, ok := item.(*ast.ResTarget); ok {+ if _, ok := target.Val.(*ast.SelectAssign); ok {+ return true+ }+ }+ }+ return false+}diff --git a/backend/plugin/db/mssql/stmt_type_test.go b/backend/plugin/db/mssql/stmt_type_test.gonew file mode 100644index 0000000000..64b4367d5b--- /dev/null+++ b/backend/plugin/db/mssql/stmt_type_test.go@@ -0,0 +1,37 @@+package mssql++import (+ "testing"++ "github.com/stretchr/testify/require"+)++func TestGetStmtType(t *testing.T) {+ for _, tc := range []struct {+ stmt string+ want stmtType+ wantErr string+ }{+ {stmt: "SELECT id FROM t", want: stmtTypeResultSetGenerating | stmtTypeRowCountGenerating},+ {stmt: "SELECT id INTO t2 FROM t", want: stmtTypeRowCountGenerating},+ {stmt: "WITH c AS (SELECT id FROM t) SELECT @id = id FROM c", want: stmtTypeUnknown},+ {stmt: "UPDATE t SET v = 1 OUTPUT inserted.id", want: stmtTypeResultSetGenerating | stmtTypeRowCountGenerating | stmtTypeOutput},+ {stmt: "DELETE FROM t OUTPUT deleted.id INTO @deleted WHERE id = 1", want: stmtTypeRowCountGenerating},+ {stmt: "INSERT INTO t VALUES (1)", want: stmtTypeRowCountGenerating},+ {stmt: "EXEC dbo.p @id = 1", want: stmtTypeProcedure},+ {stmt: "SET NOCOUNT ON", want: stmtTypeUnknown},+ {stmt: "SET NOEXEC ON", wantErr: "SET NOEXEC is not supported"},+ {stmt: "set parseonly on", wantErr: "SET PARSEONLY is not supported"},+ {stmt: "IF 1 = 1 SELECT 1", wantErr: "unsupported control flow statement"},+ } {+ t.Run(tc.stmt, func(t *testing.T) {+ got, err := getStmtType(tc.stmt)+ if tc.wantErr != "" {+ require.EqualError(t, err, tc.wantErr)+ return+ }+ require.NoError(t, err)+ require.Equal(t, tc.want, got)+ })+ }+}diff --git a/backend/plugin/db/util/driverutil.go b/backend/plugin/db/util/driverutil.goindex b9a0a1bb03..6a7f37cc70 100644--- a/backend/plugin/db/util/driverutil.go+++ b/backend/plugin/db/util/driverutil.go@@ -87,6 +87,13 @@ func parseSQLTimestamp(value string) (time.Time, error) {}func RowsToQueryResult(rows *sql.Rows, valueMaker func(string, *sql.ColumnType) any, rowValueConverter func(string, *sql.ColumnType, any) *v1pb.RowValue, limit int64) (*v1pb.QueryResult, error) {+ return RowsToLimitedQueryResult(rows, valueMaker, rowValueConverter, limit, 0)+}++// RowsToLimitedQueryResult is RowsToQueryResult keeping at most maxRows rows, so that only the+// rows it returns count towards limit. It reads the rows past maxRows without keeping them,+// leaving rows at the end of the result set.+func RowsToLimitedQueryResult(rows *sql.Rows, valueMaker func(string, *sql.ColumnType) any, rowValueConverter func(string, *sql.ColumnType, any) *v1pb.RowValue, limit int64, maxRows int) (*v1pb.QueryResult, error) {columnNames, err := rows.Columns()if err != nil {return nil, err@@ -109,6 +116,9 @@ func RowsToQueryResult(rows *sql.Rows, valueMaker func(string, *sql.ColumnType)if columnLength > 0 {for rows.Next() {+ if maxRows > 0 && len(result.Rows) >= maxRows {+ continue+ }values := make([]any, columnLength)for i, v := range columnTypeNames {values[i] = valueMaker(v, columnTypes[i])