Skip to content

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

24.0 KB
Raw Blame
// Package mssql is the plugin for MSSQL driver.
package mssql

import (
	"context"
	"database/sql"
	"fmt"
	"io"
	"log/slog"
	"maps"
	"net"
	"net/url"
	"os"
	"slices"
	"strconv"
	"strings"
	"time"

	// Import MSSQL driver.

	"github.com/golang-sql/sqlexp"
	gomssqldb "github.com/microsoft/go-mssqldb"
	"github.com/microsoft/go-mssqldb/azuread"
	"github.com/microsoft/go-mssqldb/msdsn"

	// Kerberos Active Directory authentication outside Windows.
	_ "github.com/microsoft/go-mssqldb/integratedauth/krb5"
	"github.com/pkg/errors"
	"google.golang.org/protobuf/types/known/durationpb"

	"github.com/bytebase/bytebase/backend/common/log"
	storepb "github.com/bytebase/bytebase/backend/generated-go/store"
	v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
	"github.com/bytebase/bytebase/backend/plugin/db"
	"github.com/bytebase/bytebase/backend/plugin/db/transaction"
	"github.com/bytebase/bytebase/backend/plugin/db/util"
	"github.com/bytebase/bytebase/backend/plugin/parser/base"
	tsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/tsql"
	tsqlbatch "github.com/bytebase/bytebase/backend/plugin/parser/tsql/batch"
)

var (
	_ db.Driver = (*Driver)(nil)
)

func init() {
	db.Register(storepb.Engine_MSSQL, newDriver)
}

// Driver is the MSSQL driver.
type Driver struct {
	db           *sql.DB
	databaseName string

	// certificate file path should be deleted if calling closed.
	certFilePath string
}

func newDriver() db.Driver {
	return &Driver{}
}

// Open opens a MSSQL driver.
func (d *Driver) Open(_ context.Context, _ storepb.Engine, config db.ConnectionConfig) (db.Driver, error) {
	database := config.ConnectionContext.DatabaseName
	if database == "" {
		database = config.DataSource.Database
	}
	caFile, err := writeCAFile(config.DataSource)
	if err != nil {
		return nil, err
	}
	driverName, dsn := connectionDSN(config.DataSource, config.Password, database, caFile)
	db, err := sql.Open(driverName, dsn)
	if err != nil {
		removeCAFile(caFile)
		return nil, err
	}
	d.db = db
	d.databaseName = config.ConnectionContext.DatabaseName
	d.certFilePath = caFile
	return d, nil
}

// connectionDSN returns the go-mssqldb driver name and DSN. caFile is the data source's CA
// written to disk, or empty.
//
// go-mssqldb matches parameter keys case-insensitively and accepts each key once, so Extra
// Parameters merge by lowercased key. The URL form of a DSN already derives user id and password
// from the userinfo and server and port from the host, and the driver rejects a second value for
// any of them, so the credentials travel in the query and the server and port in the host, each
// once. A named instance has to go in the path, because the host cannot hold the backslash of
// Server=host\instance. Extra Parameters override the app name, tlsmin, credentials, server and
// port, never the database or the Azure credential. With TLS mode TLS, the TLS section sets a
// floor that Extra Parameters may raise but not lower: encrypt=true unless they ask for
// encrypt=strict, and TrustServerCertificate=false when Verify server certificate is on or they
// ask for it. The section's CA replaces a certificate parameter. With TLS mode Disabled, Extra
// Parameters apply as given over a TrustServerCertificate=true default.
func connectionDSN(ds *storepb.DataSource, password, database, caFile string) (string, string) {
	params := map[string]string{
		msdsn.AppName: "bytebase",
		// Older SQL Server versions offer only TLS 1.0: https://github.com/microsoft/go-mssqldb/issues/33.
		msdsn.TLSMin:   "1.0",
		msdsn.UserID:   ds.Username,
		msdsn.Password: password,
	}
	extra := ds.GetExtraConnectionParameters()
	// Sorted, so keys that differ only in case resolve the same way every time.
	for _, key := range slices.Sorted(maps.Keys(extra)) {
		params[strings.ToLower(key)] = extra[key]
	}
	if database != "" {
		params[msdsn.Database] = database
	}
	if ds.GetUseSsl() {
		if !strings.EqualFold(params[msdsn.Encrypt], "strict") {
			params[msdsn.Encrypt] = "true"
		}
		trust, err := strconv.ParseBool(params[msdsn.TrustServerCertificate])
		verify := ds.GetVerifyTlsCertificate() || (err == nil && !trust)
		params[msdsn.TrustServerCertificate] = strconv.FormatBool(!verify)
		if caFile != "" {
			params[msdsn.Certificate] = caFile
		}
	} else if _, ok := params[msdsn.TrustServerCertificate]; !ok {
		params[msdsn.TrustServerCertificate] = "true"
	}

	driverName := "sqlserver"
	if ds.GetAuthenticationType() == storepb.DataSource_AZURE_IAM {
		driverName = azuread.DriverName
		if credential := ds.GetAzureCredential(); credential != nil {
			params["fedauth"] = azuread.ActiveDirectoryServicePrincipal
			params[msdsn.UserID] = fmt.Sprintf("%s@%s", credential.ClientId, credential.TenantId)
			params[msdsn.Password] = credential.ClientSecret
		} else {
			params["fedauth"] = azuread.ActiveDirectoryDefault
		}
	}

	host, port := ds.Host, ds.Port
	if server, ok := params[msdsn.Server]; ok {
		delete(params, msdsn.Server)
		host = server
	}
	if value, ok := params[msdsn.Port]; ok {
		delete(params, msdsn.Port)
		port = value
	}
	instance := ""
	if before, after, ok := strings.Cut(host, `\`); ok {
		host, instance = before, after
	}
	// net.JoinHostPort brackets an IPv6 literal, which the URL host needs and the driver strips
	// back off, so a value that already carries brackets must not get a second pair.
	host = strings.TrimSuffix(strings.TrimPrefix(host, "["), "]")

	query := url.Values{}
	for key, value := range params {
		query.Set(key, value)
	}
	u := &url.URL{
		Scheme:   "sqlserver",
		Host:     net.JoinHostPort(host, port),
		RawQuery: query.Encode(),
	}
	if instance != "" {
		u.Path = "/" + instance
	}
	return driverName, u.String()
}

// writeCAFile writes the data source's CA to a temporary file, because go-mssqldb reads a CA only
// from a .pem or .der path. It returns "" when TLS is off or no CA is set.
func writeCAFile(ds *storepb.DataSource) (string, error) {
	if !ds.GetUseSsl() || ds.GetSslCa() == "" {
		return "", nil
	}
	file, err := os.CreateTemp("", "cert-*.pem")
	if err != nil {
		return "", errors.Wrap(err, "failed to create the CA certificate file")
	}
	_, err = file.WriteString(ds.GetSslCa())
	if closeErr := file.Close(); err == nil {
		err = closeErr
	}
	if err != nil {
		removeCAFile(file.Name())
		return "", errors.Wrap(err, "failed to write the CA certificate file")
	}
	return file.Name(), nil
}

func removeCAFile(path string) {
	if path == "" {
		return
	}
	if err := os.Remove(path); err != nil {
		slog.Warn("failed to delete temporary file", slog.String("path", path), log.BBError(err))
	}
}

// Close closes the driver.
func (d *Driver) Close(_ context.Context) error {
	removeCAFile(d.certFilePath)
	if d.db != nil {
		return d.db.Close()
	}
	return nil
}

// Ping pings the database.
func (d *Driver) Ping(ctx context.Context) error {
	return d.db.PingContext(ctx)
}

// GetDB gets the database.
func (d *Driver) GetDB() *sql.DB {
	return d.db
}

// Execute executes a SQL statement and returns the affected rows.
func (d *Driver) Execute(ctx context.Context, statement string, opts db.ExecuteOptions) (int64, error) {
	if opts.CreateDatabase {
		if _, err := d.db.ExecContext(ctx, statement); err != nil {
			return 0, err
		}
		return 0, nil
	}

	// Parse transaction mode from the script
	config, cleanedStatement := base.ParseTransactionConfig(statement)
	statement = cleanedStatement
	transactionMode := config.Mode

	// Apply default when transaction mode is not specified
	if transactionMode == transaction.ModeUnspecified {
		transactionMode = transaction.DefaultMode()
	}

	// Execute based on transaction mode
	if transactionMode == transaction.ModeOff {
		return d.executeInAutoCommitMode(ctx, statement, opts)
	}
	return d.executeInTransactionMode(ctx, statement, opts)
}

// executeInTransactionMode executes statements within a single transaction
func (d *Driver) executeInTransactionMode(ctx context.Context, statement string, opts db.ExecuteOptions) (int64, error) {
	tx, err := d.db.BeginTx(ctx, nil)
	if err != nil {
		opts.LogTransactionControl(storepb.TaskRunLog_TransactionControl_BEGIN, err.Error())
		return 0, err
	}
	opts.LogTransactionControl(storepb.TaskRunLog_TransactionControl_BEGIN, "")

	committed := false
	defer func() {
		err := tx.Rollback()
		if committed {
			return
		}
		var rerr string
		if err != nil {
			rerr = err.Error()
		}
		opts.LogTransactionControl(storepb.TaskRunLog_TransactionControl_ROLLBACK, rerr)
	}()

	totalAffectRows := int64(0)

	batch := tsqlbatch.NewBatcher(statement)

	for idx := 0; ; {
		command, err := batch.Next()
		if err != nil {
			if err == io.EOF {
				// Try send the last batch to server.
				v := batch.Batch()
				if v != nil && len(v.Text) > 0 {
					opts.LogCommandExecute(&storepb.Range{Start: int32(v.Start), End: int32(v.End)}, v.Text)
					rowsAffected, err := execute(ctx, tx, v.Text)
					if err != nil {
						opts.LogCommandResponse(0, nil, err.Error())
						return 0, err
					}
					opts.LogCommandResponse(rowsAffected, []int64{rowsAffected}, "")
					totalAffectRows += rowsAffected
				}
				break
			}
			return 0, errors.Wrapf(err, "failed to get next batch for statement: %s", batch.Batch().Text)
		}
		if command == nil {
			continue
		}
		switch v := command.(type) {
		case *tsqlbatch.GoCommand:
			b := batch.Batch()
			// Try send the batch to server.
			idx++
			for i := uint(0); i < v.Count; i++ {
				opts.LogCommandExecute(&storepb.Range{Start: int32(b.Start), End: int32(b.End)}, b.Text)
				rowsAffected, err := execute(ctx, tx, b.Text)
				if err != nil {
					opts.LogCommandResponse(0, nil, err.Error())
					return 0, err
				}
				opts.LogCommandResponse(rowsAffected, []int64{rowsAffected}, "")
				totalAffectRows += rowsAffected
			}
		default:
			return 0, errors.Errorf("unsupported command type: %T", v)
		}
		batch.Reset(nil)
	}

	if err := tx.Commit(); err != nil {
		opts.LogTransactionControl(storepb.TaskRunLog_TransactionControl_COMMIT, err.Error())
		return 0, err
	}
	opts.LogTransactionControl(storepb.TaskRunLog_TransactionControl_COMMIT, "")
	committed = true
	return totalAffectRows, nil
}

// executeInAutoCommitMode executes statements sequentially in auto-commit mode
func (d *Driver) executeInAutoCommitMode(ctx context.Context, statement string, opts db.ExecuteOptions) (int64, error) {
	totalAffectRows := int64(0)

	batch := tsqlbatch.NewBatcher(statement)

	for idx := 0; ; {
		command, err := batch.Next()
		if err != nil {
			if err == io.EOF {
				// Try send the last batch to server.
				v := batch.Batch()
				if v != nil && len(v.Text) > 0 {
					opts.LogCommandExecute(&storepb.Range{Start: int32(v.Start), End: int32(v.End)}, v.Text)
					rowsAffected, err := d.executeAutoCommit(ctx, v.Text)
					if err != nil {
						opts.LogCommandResponse(0, nil, err.Error())
						return totalAffectRows, err
					}
					opts.LogCommandResponse(rowsAffected, []int64{rowsAffected}, "")
					totalAffectRows += rowsAffected
				}
				break
			}
			return 0, errors.Wrapf(err, "failed to get next batch for statement: %s", batch.Batch().Text)
		}
		if command == nil {
			continue
		}
		switch v := command.(type) {
		case *tsqlbatch.GoCommand:
			b := batch.Batch()
			// Execute the batch in auto-commit mode
			idx++
			for i := uint(0); i < v.Count; i++ {
				opts.LogCommandExecute(&storepb.Range{Start: int32(b.Start), End: int32(b.End)}, b.Text)
				rowsAffected, err := d.executeAutoCommit(ctx, b.Text)
				if err != nil {
					opts.LogCommandResponse(0, nil, err.Error())
					// In auto-commit mode, we stop at the first error
					return totalAffectRows, err
				}
				opts.LogCommandResponse(rowsAffected, []int64{rowsAffected}, "")
				totalAffectRows += rowsAffected
			}
		default:
			return 0, errors.Errorf("unsupported command type: %T", v)
		}
		batch.Reset(nil)
	}

	return totalAffectRows, nil
}

// executeAutoCommit executes a single statement in auto-commit mode
func (d *Driver) executeAutoCommit(ctx context.Context, statement string) (int64, error) {
	sqlResult, err := d.db.ExecContext(ctx, statement)
	if err != nil {
		return 0, errors.Wrap(err, "failed to execute statement in auto-commit mode")
	}
	rowsAffected, err := sqlResult.RowsAffected()
	if err != nil {
		// Since we cannot differentiate DDL and DML yet, we have to ignore the error.
		slog.Debug("rowsAffected returns error in auto-commit mode", log.BBError(err))
		return 0, nil
	}
	return rowsAffected, nil
}

func execute(ctx context.Context, txn *sql.Tx, statement string) (int64, error) {
	sqlResult, err := txn.ExecContext(ctx, statement)
	var e gomssqldb.Error
	if errors.As(err, &e) {
		err = unpackGoMSSQLDBError(e)
	}
	if err != nil {
		return 0, errors.Wrap(err, "failed to execute statement")
	}
	rowsAffected, err := sqlResult.RowsAffected()
	if err != nil {
		// Since we cannot differentiate DDL and DML yet, we have to ignore the error.
		slog.Debug("rowsAffected returns error", log.BBError(err))
		return 0, nil
	}
	return rowsAffected, nil
}

func formatMSSQLError(e gomssqldb.Error) string {
	b := new(strings.Builder)
	if len(e.ProcName) > 0 {
		fmt.Fprintf(b, "Msg %d, Level %d, State %d, Server %s, Procedure %s, Line %d\n", e.Number, e.Class, e.State, e.ServerName, e.ProcName, e.LineNo)
	} else {
		fmt.Fprintf(b, "Msg %d, Level %d, State %d, Server %s, Line %d\n", e.Number, e.Class, e.State, e.ServerName, e.LineNo)
	}
	b.WriteString(e.Message)
	return b.String()
}

func unpackGoMSSQLDBError(err gomssqldb.Error) error {
	if len(err.All) == 0 || len(err.All) == 1 {
		return errors.Errorf("%s", formatMSSQLError(err))
	}
	var msgs []string
	for _, e := range err.All {
		if e.Message == "" {
			continue
		}
		msgs = append(msgs, formatMSSQLError(e))
	}
	return errors.Errorf("%s", strings.Join(msgs, "\n"))
}

func (d *Driver) QueryConn(ctx context.Context, conn *sql.Conn, statement string, queryContext db.QueryContext) ([]*v1pb.QueryResult, error) {
	// Special handling for EXPLAIN queries in MSSQL is now integrated into queryBatch

	// Regular query processing (unchanged)
	batch := tsqlbatch.NewBatcher(statement)
	// 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 {
			if err == io.EOF {
				v := batch.Batch()
				if v != nil && len(v.Text) > 0 {
					// Query the last batch.
					qr, more, err := d.queryBatch(ctx, conn, v.Text, queryContext)
					results = append(results, qr...)
					procedureResults = append(procedureResults, more...)
					if err != nil {
						return results, err
					}
				}
				batch.Reset(nil)
				break
			}
			return results, errors.Wrapf(err, "failed to get next batch for statement: %s", batch.Batch().Text)
		}
		if command == nil {
			continue
		}
		switch v := command.(type) {
		case *tsqlbatch.GoCommand:
			b := batch.Batch()
			// Query the batch.
			qr, more, err := d.queryBatch(ctx, conn, b.Text, queryContext)
			results = append(results, qr...)
			procedureResults = append(procedureResults, more...)
			if err != nil {
				return results, err
			}
		default:
			return results, errors.Errorf("unsupported command type: %T", v)
		}
		batch.Reset(nil)
	}
	return append(results, procedureResults...), nil
}

// showplanStatistic picks the SET statement that turns on the requested explain
// output. SQL Server has no JSON showplan; which formats an engine may be asked
// for is decided at the API boundary (validateExplainFormat), so anything else
// arriving here takes the default plan.
func showplanStatistic(option *v1pb.QueryOption) string {
	if option.GetExplainFormat() == v1pb.QueryOption_XML {
		return "SHOWPLAN_XML"
	}
	return "SHOWPLAN_ALL"
}

// 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, []*v1pb.QueryResult, error) {
	singleSQLs, err := tsqlparser.SplitSQL(batch)
	if err != nil {
		return nil, nil, err
	}
	singleSQLs = base.FilterEmptyStatements(singleSQLs)
	if len(singleSQLs) == 0 {
		return nil, nil, nil
	}

	// Special handling for EXPLAIN queries in MSSQL using explain
	if queryContext.Explain {
		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, nil, errors.Wrap(err, "failed to enable explain mode")
		}
		// Ensure explain is turned off after processing
		defer func() {
			if _, err := conn.ExecContext(ctx, fmt.Sprintf("SET %s OFF", explain)); err != nil { // NOSONAR(go:S2077) explain is a hardcoded constant ("SHOWPLAN_ALL" or "SHOWPLAN_XML"), not user input
				slog.Warn("failed to disable explain mode", log.BBError(err))
			}
		}()

		var results []*v1pb.QueryResult

		// Process each statement with explain enabled
		for _, singleSQL := range singleSQLs {
			startTime := time.Now()

			queryResult, err := func() (*v1pb.QueryResult, error) {
				// Execute query to get execution plan
				rows, err := conn.QueryContext(ctx, singleSQL.Text)
				if err != nil {
					return nil, errors.Wrap(err, "failed to get execution plan")
				}
				defer rows.Close()

				// Convert to query result
				r, err := util.RowsToQueryResult(rows, makeValueByTypeName, convertValue, queryContext.MaximumSQLResultSize)
				if err != nil {
					return nil, errors.Wrap(err, "failed to convert execution plan results")
				}

				if err = rows.Err(); err != nil {
					return nil, errors.Wrap(err, "error after processing rows")
				}

				return r, nil
			}()

			stop := false
			if err != nil {
				queryResult = &v1pb.QueryResult{
					Error: err.Error(),
				}
				stop = true
			}

			queryResult.Statement = singleSQL.Text
			queryResult.Latency = durationpb.New(time.Since(startTime))
			queryResult.RowsCount = int64(len(queryResult.Rows))

			results = append(results, queryResult)
			if stop {
				break
			}
		}

		return results, nil, nil
	}

	// Regular query processing for non-EXPLAIN queries
	startTime := time.Now()
	var stmtTypes []stmtType
	var refinedSQLs []string
	batchBuf := new(strings.Builder)
	for _, singleSQL := range singleSQLs {
		stmtType, err := getStmtType(singleSQL.Text)
		if err != nil {
			return nil, nil, err
		}
		stmtTypes = append(stmtTypes, stmtType)
		// Before sending the batch to server, we add the limit clause to the statement.
		s := singleSQL.Text
		if queryContext.Limit > 0 {
			s = base.StatementWithResultLimit(storepb.Engine_MSSQL, s, queryContext.Limit, "")
		}
		refinedSQLs = append(refinedSQLs, s)
		if _, err := batchBuf.WriteString(s); err != nil {
			return nil, nil, err
		}
		if _, err := batchBuf.WriteString("\n"); err != nil {
			return nil, nil, err
		}
	}

	refinedBatch := batchBuf.String()
	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, nil, qe
	}
	defer rows.Close()
	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 nil, nil, err
			}
		case sqlexp.MsgError:
			err := m.Error
			var e gomssqldb.Error
			if errors.As(err, &e) {
				err = unpackGoMSSQLDBError(e)
			}
			return nil, nil, err
		case sqlexp.MsgRowsAffected:
			// The count that closes a result set is the result set's own row count.
			if !inResultSet {
				rowCounts = append(rowCounts, m.Count)
			}
		case sqlexp.MsgNextResultSet:
			inResultSet = false
			more = rows.NextResultSet()
			if err = rows.Err(); err != nil {
				return nil, nil, err
			}
		case sqlexp.MsgNext:
			result, err := readResultSet(rows, queryContext)
			if err != nil {
				return nil, nil, err
			}
			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 _, res := range slices.Concat(results, procedureResults) {
		res.Latency = durationpb.New(latency)
	}
	return results, procedureResults, 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 {
	if err == nil {
		return nil
	}
	var errState uint8
	switch sqlError := err.(type) {
	case gomssqldb.Error:
		errState = sqlError.State
	default:
	}
	// 127 is the magic exit code
	if errState == 127 {
		return errors.Errorf("meet exit error, state: %d", errState)
	}
	return nil
}