Skip to content

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

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.go
index 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 = maskingEnabled
if 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.go
index 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 int64
Timeout *durationpb.Duration
diff --git a/backend/plugin/db/mssql/mssql.go b/backend/plugin/db/mssql/mssql.go
index 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.QueryResult
for {
command, err := batch.Next()
if err != nil {
@@ -386,8 +389,9 @@ func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string
v := 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 string
case *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, que
explain := showplanStatistic(queryContext.Option)
// Enable explain mode once for all statements
if _, 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 processing
defer 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, que
for _, 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, que
retmsg := &sqlexp.ReturnMessage{}
rows, qe := conn.QueryContext(ctx, refinedBatch, retmsg) // NOSONAR(go:S2077) intentional execution of user-authored SQL in SQL Editor
if 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, que
if errors.As(err, &e) {
err = unpackGoMSSQLDBError(e)
}
- queryResult.Error = err.Error()
- ret = append(ret, queryResult)
- return ret, err
+ return nil, nil, err
case 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 = true
default:
}
}
+ 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.go
index 93a2a32474..4634197668 100644
--- a/backend/plugin/db/mssql/mssql_test.go
+++ b/backend/plugin/db/mssql/mssql_test.go
@@ -2,7 +2,10 @@ package mssql
import (
"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.go
index 37b9653799..4eedd8a169 100644
--- a/backend/plugin/db/mssql/stmt_type.go
+++ b/backend/plugin/db/mssql/stmt_type.go
@@ -1,6 +1,8 @@
package mssql
import (
+ "strings"
+
"github.com/bytebase/omni/mssql/ast"
"github.com/pkg/errors"
@@ -11,8 +13,13 @@ type stmtType = int
const (
stmtTypeUnknown = 1 << iota
+ // stmtTypeResultSetGenerating returns exactly one result set.
stmtTypeResultSetGenerating
stmtTypeRowCountGenerating
+ // 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.go
new file mode 100644
index 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.go
index 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])