17178144630

Committed 23 Aug 2025 05:20PM UTC coverage: 56.309% (-0.005%) from 56.314%

Build # 17178144630

Build Type

Pull #1308

github

Committed by

chandrakant-cohesity

Commit Message

Fixed defer block

Pull Request Pull Request #1308: Ensure bufferWriter is always closed in Migration.Buffer and propagate close errors

Run Details

7 of 11 new or added lines in 1 file covered. (63.64%)

557 existing lines in 16 files now uncovered.

4561 of 8100 relevant lines covered (56.31%)

50.12 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.43

/database/sqlserver/sqlserver.go

package sqlserver

import (
        "context"
        "database/sql"
        "fmt"
        "io"
        nurl "net/url"
        "strconv"
        "strings"

        "go.uber.org/atomic"

        "github.com/Azure/go-autorest/autorest/adal"
        "github.com/golang-migrate/migrate/v4"
        "github.com/golang-migrate/migrate/v4/database"
        "github.com/hashicorp/go-multierror"
        mssql "github.com/microsoft/go-mssqldb" // mssql support
)

func init() {
        database.Register("sqlserver", &SQLServer{})
}

// DefaultMigrationsTable is the name of the migrations table in the database
var DefaultMigrationsTable = "schema_migrations"

var (
        ErrNilConfig                 = fmt.Errorf("no config")
        ErrNoDatabaseName            = fmt.Errorf("no database name")
        ErrNoSchema                  = fmt.Errorf("no schema")
        ErrDatabaseDirty             = fmt.Errorf("database is dirty")
        ErrMultipleAuthOptionsPassed = fmt.Errorf("both password and useMsi=true were passed.")
)

var lockErrorMap = map[int]string{
        -1:   "The lock request timed out.",
        -2:   "The lock request was canceled.",
        -3:   "The lock request was chosen as a deadlock victim.",
        -999: "Parameter validation or other call error.",
}

// Config for database
type Config struct {
        MigrationsTable string
        DatabaseName    string
        SchemaName      string
}

// SQL Server connection
type SQLServer struct {
        // Locking and unlocking need to use the same connection
        conn     *sql.Conn
        db       *sql.DB
        isLocked atomic.Bool

        // Open and WithInstance need to garantuee that config is never nil
        config *Config
}

// WithInstance returns a database instance from an already created database connection.
//
// Note that the deprecated `mssql` driver is not supported. Please use the newer `sqlserver` driver.
func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) {
        if config == nil {
                return nil, ErrNilConfig
        }

        if err := instance.Ping(); err != nil {
                return nil, err
        }

        if config.DatabaseName == "" {
                query := `SELECT DB_NAME()`
                var databaseName string
                if err := instance.QueryRow(query).Scan(&databaseName); err != nil {
                        return nil, &database.Error{OrigErr: err, Query: []byte(query)}
                }

                if len(databaseName) == 0 {
                        return nil, ErrNoDatabaseName
                }

                config.DatabaseName = databaseName
        }

        if config.SchemaName == "" {
                query := `SELECT SCHEMA_NAME()`
                var schemaName string
                if err := instance.QueryRow(query).Scan(&schemaName); err != nil {
                        return nil, &database.Error{OrigErr: err, Query: []byte(query)}
                }

                if len(schemaName) == 0 {
                        return nil, ErrNoSchema
                }

                config.SchemaName = schemaName
        }

        if len(config.MigrationsTable) == 0 {
                config.MigrationsTable = DefaultMigrationsTable
        }

        conn, err := instance.Conn(context.Background())

        if err != nil {
                return nil, err
        }

        ss := &SQLServer{
                conn:   conn,
                db:     instance,
                config: config,
        }

        if err := ss.ensureVersionTable(); err != nil {
                return nil, err
        }

        return ss, nil
}

// Open a connection to the database.
func (ss *SQLServer) Open(url string) (database.Driver, error) {
        purl, err := nurl.Parse(url)
        if err != nil {
                return nil, err
        }

        useMsiParam := purl.Query().Get("useMsi")
        useMsi := false
        if len(useMsiParam) > 0 {
                useMsi, err = strconv.ParseBool(useMsiParam)
                if err != nil {
                        return nil, err
                }
        }

        if _, isPasswordSet := purl.User.Password(); useMsi && isPasswordSet {
                return nil, ErrMultipleAuthOptionsPassed
        }

        filteredURL := migrate.FilterCustomQuery(purl).String()

        var db *sql.DB
        if useMsi {
                resource := getAADResourceFromServerUri(purl)
                tokenProvider, err := getMSITokenProvider(resource)
                if err != nil {
                        return nil, err
                }

                connector, err := mssql.NewAccessTokenConnector(
                        filteredURL, tokenProvider)
                if err != nil {
                        return nil, err
                }

                db = sql.OpenDB(connector)

        } else {
                db, err = sql.Open("sqlserver", filteredURL)
                if err != nil {
                        return nil, err
                }
        }

        migrationsTable := purl.Query().Get("x-migrations-table")

        px, err := WithInstance(db, &Config{
                DatabaseName:    purl.Path,
                MigrationsTable: migrationsTable,
        })

        if err != nil {
                return nil, err
        }

        return px, nil
}

// Close the database connection
func (ss *SQLServer) Close() error {
        connErr := ss.conn.Close()
        dbErr := ss.db.Close()
        if connErr != nil || dbErr != nil {
                return fmt.Errorf("conn: %v, db: %v", connErr, dbErr)
        }
        return nil
}

// Lock creates an advisory local on the database to prevent multiple migrations from running at the same time.
func (ss *SQLServer) Lock() error {
        return database.CasRestoreOnErr(&ss.isLocked, false, true, database.ErrLocked, func() error {
                aid, err := database.GenerateAdvisoryLockId(ss.config.DatabaseName, ss.config.SchemaName)
                if err != nil {
                        return err
                }

                // This will block until the lock is acquired.
                // MS Docs: sp_getapplock: https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-getapplock-transact-sql?view=sql-server-2017
                query := `
                DECLARE @lockResult int;
                EXEC @lockResult = sp_getapplock @Resource = @p1, @LockMode = 'Exclusive', @LockOwner = 'Session', @LockTimeout = -1;
                SELECT @lockResult;`

                var status int
                if err = ss.conn.QueryRowContext(context.Background(), query, aid).Scan(&status); err == nil && status > -1 {
                        return nil
                } else if err != nil {
                        return &database.Error{OrigErr: err, Err: "try lock failed", Query: []byte(query)}
                } else {
                        errorDescription, ok := lockErrorMap[status]
                        if !ok {
                                errorDescription = "Unknown error"
                        }
                        return &database.Error{Err: fmt.Sprintf("try lock failed with error %v: %v", status, errorDescription), Query: []byte(query)}
                }
        })
}

// Unlock froms the migration lock from the database
func (ss *SQLServer) Unlock() error {
        return database.CasRestoreOnErr(&ss.isLocked, true, false, database.ErrNotLocked, func() error {
                aid, err := database.GenerateAdvisoryLockId(ss.config.DatabaseName, ss.config.SchemaName)
                if err != nil {
                        return err
                }

                // MS Docs: sp_releaseapplock: https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-releaseapplock-transact-sql?view=sql-server-2017
                query := `EXEC sp_releaseapplock @Resource = @p1, @LockOwner = 'Session'`
                if _, err := ss.conn.ExecContext(context.Background(), query, aid); err != nil {
                        return &database.Error{OrigErr: err, Query: []byte(query)}
                }

                return nil
        })
}

// Run the migrations for the database
func (ss *SQLServer) Run(migration io.Reader) error {
        migr, err := io.ReadAll(migration)
        if err != nil {
                return err
        }

        // run migration
        query := string(migr[:])
        if _, err := ss.conn.ExecContext(context.Background(), query); err != nil {
                if msErr, ok := err.(mssql.Error); ok {
                        message := fmt.Sprintf("migration failed: %s", msErr.Message)
                        if msErr.ProcName != "" {
                                message = fmt.Sprintf("%s (proc name %s)", msErr.Message, msErr.ProcName)
                        }
                        return database.Error{OrigErr: err, Err: message, Query: migr, Line: uint(msErr.LineNo)}
                }
                return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
        }

        return nil
}

// SetVersion for the current database
func (ss *SQLServer) SetVersion(version int, dirty bool) error {

        tx, err := ss.conn.BeginTx(context.Background(), &sql.TxOptions{})
        if err != nil {
                return &database.Error{OrigErr: err, Err: "transaction start failed"}
        }

        query := `TRUNCATE TABLE ` + ss.getMigrationTable()
        if _, err := tx.Exec(query); err != nil {
                if errRollback := tx.Rollback(); errRollback != nil {
                        err = multierror.Append(err, errRollback)
                }
                return &database.Error{OrigErr: err, Query: []byte(query)}
        }

        // Also re-write the schema version for nil dirty versions to prevent
        // empty schema version for failed down migration on the first migration
        // See: https://github.com/golang-migrate/migrate/issues/330
        if version >= 0 || (version == database.NilVersion && dirty) {
                var dirtyBit int
                if dirty {
                        dirtyBit = 1
                }
                query = `INSERT INTO ` + ss.getMigrationTable() + ` (version, dirty) VALUES (@p1, @p2)`
                if _, err := tx.Exec(query, version, dirtyBit); err != nil {
                        if errRollback := tx.Rollback(); errRollback != nil {
                                err = multierror.Append(err, errRollback)
                        }
                        return &database.Error{OrigErr: err, Query: []byte(query)}
                }
        }

        if err := tx.Commit(); err != nil {
                return &database.Error{OrigErr: err, Err: "transaction commit failed"}
        }

        return nil
}

// Version of the current database state
func (ss *SQLServer) Version() (version int, dirty bool, err error) {
        query := `SELECT TOP 1 version, dirty FROM ` + ss.getMigrationTable()
        err = ss.conn.QueryRowContext(context.Background(), query).Scan(&version, &dirty)
        switch {
        case err == sql.ErrNoRows:
                return database.NilVersion, false, nil

        case err != nil:
                // FIXME: convert to MSSQL error
                return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}

        default:
                return version, dirty, nil
        }
}

// Drop all tables from the database.
func (ss *SQLServer) Drop() error {

        // drop all referential integrity constraints
        query := `
        DECLARE @Sql NVARCHAR(500) DECLARE @Cursor CURSOR

        SET @Cursor = CURSOR FAST_FORWARD FOR
        SELECT DISTINCT sql = 'ALTER TABLE [' + tc2.TABLE_NAME + '] DROP [' + rc1.CONSTRAINT_NAME + ']'
        FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc1
        LEFT JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc2 ON tc2.CONSTRAINT_NAME =rc1.CONSTRAINT_NAME

        OPEN @Cursor FETCH NEXT FROM @Cursor INTO @Sql

        WHILE (@@FETCH_STATUS = 0)
        BEGIN
        Exec sp_executesql @Sql
        FETCH NEXT FROM @Cursor INTO @Sql
        END

        CLOSE @Cursor DEALLOCATE @Cursor`

        if _, err := ss.conn.ExecContext(context.Background(), query); err != nil {
                return &database.Error{OrigErr: err, Query: []byte(query)}
        }

        // drop the tables
        query = `EXEC sp_MSforeachtable 'DROP TABLE ?'`
        if _, err := ss.conn.ExecContext(context.Background(), query); err != nil {
                return &database.Error{OrigErr: err, Query: []byte(query)}
        }

        return nil
}

func (ss *SQLServer) ensureVersionTable() (err error) {
        if err = ss.Lock(); err != nil {
                return err
        }

        defer func() {
                if e := ss.Unlock(); e != nil {
                        if err == nil {
                                err = e
                        } else {
                                err = multierror.Append(err, e)
                        }
                }
        }()

        query := `IF NOT EXISTS
        (SELECT *
                 FROM sysobjects
                WHERE id = object_id(N'` + ss.getMigrationTable() + `')
                        AND OBJECTPROPERTY(id, N'IsUserTable') = 1
        )
        CREATE TABLE ` + ss.getMigrationTable() + ` ( version BIGINT PRIMARY KEY NOT NULL, dirty BIT NOT NULL );`

        if _, err = ss.conn.ExecContext(context.Background(), query); err != nil {
                return &database.Error{OrigErr: err, Query: []byte(query)}
        }

        return nil
}

func (ss *SQLServer) getMigrationTable() string {
        return fmt.Sprintf("[%s].[%s]", ss.config.SchemaName, ss.config.MigrationsTable)
}

func getMSITokenProvider(resource string) (func() (string, error), error) {
        msi, err := adal.NewServicePrincipalTokenFromManagedIdentity(resource, nil)
        if err != nil {
                return nil, err
        }

        return func() (string, error) {
                err := msi.EnsureFresh()
                if err != nil {
                        return "", err
                }
                token := msi.OAuthToken()
                return token, nil
        }, nil
}

// The sql server resource can change across clouds so get it
// dynamically based on the server uri.
// ex. <server name>.database.windows.net -> https://database.windows.net
func getAADResourceFromServerUri(purl *nurl.URL) string {
        return fmt.Sprintf("%s%s", "https://", strings.Join(strings.Split(purl.Hostname(), ".")[1:], "."))
}

1	package sqlserver
2
3	import (
4	"context"
5	"database/sql"
6	"fmt"
7	"io"
8	nurl "net/url"
9	"strconv"
10	"strings"
11
12	"go.uber.org/atomic"
13
14	"github.com/Azure/go-autorest/autorest/adal"
15	"github.com/golang-migrate/migrate/v4"
16	"github.com/golang-migrate/migrate/v4/database"
17	"github.com/hashicorp/go-multierror"
18	mssql "github.com/microsoft/go-mssqldb" // mssql support
19	)
20		2✔
21	func init() {	2✔
22	database.Register("sqlserver", &SQLServer{})	2✔
23	}
24
25	// DefaultMigrationsTable is the name of the migrations table in the database
26	var DefaultMigrationsTable = "schema_migrations"
27
28	var (
29	ErrNilConfig = fmt.Errorf("no config")
30	ErrNoDatabaseName = fmt.Errorf("no database name")
31	ErrNoSchema = fmt.Errorf("no schema")
32	ErrDatabaseDirty = fmt.Errorf("database is dirty")
33	ErrMultipleAuthOptionsPassed = fmt.Errorf("both password and useMsi=true were passed.")
34	)
35
36	var lockErrorMap = map[int]string{
37	-1: "The lock request timed out.",
38	-2: "The lock request was canceled.",
39	-3: "The lock request was chosen as a deadlock victim.",
40	-999: "Parameter validation or other call error.",
41	}
42
43	// Config for database
44	type Config struct {
45	MigrationsTable string
46	DatabaseName string
47	SchemaName string
48	}
49
50	// SQL Server connection
51	type SQLServer struct {
52	// Locking and unlocking need to use the same connection
53	conn *sql.Conn
54	db *sql.DB
55	isLocked atomic.Bool
56
57	// Open and WithInstance need to garantuee that config is never nil
58	config *Config
59	}
60
61	// WithInstance returns a database instance from an already created database connection.
62	//
63	// Note that the deprecated `mssql` driver is not supported. Please use the newer `sqlserver` driver.	32✔
64	func WithInstance(instance sql.DB, config Config) (database.Driver, error) {	32✔
UNCOV 65	if config == nil {	×
66	return nil, ErrNilConfig	×
67	}
68		40✔
69	if err := instance.Ping(); err != nil {	8✔
70	return nil, err	8✔
71	}
72		48✔
73	if config.DatabaseName == "" {	24✔
74	query := `SELECT DB_NAME()`	24✔
75	var databaseName string	24✔
UNCOV 76	if err := instance.QueryRow(query).Scan(&databaseName); err != nil {	×
77	return nil, &database.Error{OrigErr: err, Query: []byte(query)}	×
78	}
79		24✔
UNCOV 80	if len(databaseName) == 0 {	×
81	return nil, ErrNoDatabaseName	×
82	}
83		24✔
84	config.DatabaseName = databaseName
85	}
86		48✔
87	if config.SchemaName == "" {	24✔
88	query := `SELECT SCHEMA_NAME()`	24✔
89	var schemaName string	24✔
UNCOV 90	if err := instance.QueryRow(query).Scan(&schemaName); err != nil {	×
91	return nil, &database.Error{OrigErr: err, Query: []byte(query)}	×
92	}
93		24✔
UNCOV 94	if len(schemaName) == 0 {	×
95	return nil, ErrNoSchema	×
96	}
97		24✔
98	config.SchemaName = schemaName
99	}
100		48✔
101	if len(config.MigrationsTable) == 0 {	24✔
102	config.MigrationsTable = DefaultMigrationsTable	24✔
103	}
104		24✔
105	conn, err := instance.Conn(context.Background())	24✔
106		24✔
UNCOV 107	if err != nil {	×
108	return nil, err	×
109	}
110		24✔
111	ss := &SQLServer{	24✔
112	conn: conn,	24✔
113	db: instance,	24✔
114	config: config,	24✔
115	}	24✔
116		24✔
UNCOV 117	if err := ss.ensureVersionTable(); err != nil {	×
118	return nil, err	×
119	}
120		24✔
121	return ss, nil
122	}
123
124	// Open a connection to the database.	36✔
125	func (ss *SQLServer) Open(url string) (database.Driver, error) {	36✔
126	purl, err := nurl.Parse(url)	36✔
UNCOV 127	if err != nil {	×
128	return nil, err	×
129	}
130		36✔
131	useMsiParam := purl.Query().Get("useMsi")	36✔
132	useMsi := false	52✔
133	if len(useMsiParam) > 0 {	16✔
134	useMsi, err = strconv.ParseBool(useMsiParam)	16✔
UNCOV 135	if err != nil {	×
136	return nil, err	×
137	}
138	}
139		40✔
140	if _, isPasswordSet := purl.User.Password(); useMsi && isPasswordSet {	4✔
141	return nil, ErrMultipleAuthOptionsPassed	4✔
142	}
143		32✔
144	filteredURL := migrate.FilterCustomQuery(purl).String()	32✔
145		32✔
146	var db *sql.DB	36✔
147	if useMsi {	4✔
148	resource := getAADResourceFromServerUri(purl)	4✔
149	tokenProvider, err := getMSITokenProvider(resource)	4✔
UNCOV 150	if err != nil {	×
151	return nil, err	×
152	}
153		4✔
154	connector, err := mssql.NewAccessTokenConnector(	4✔
155	filteredURL, tokenProvider)	4✔
UNCOV 156	if err != nil {	×
157	return nil, err	×
158	}
159		4✔
160	db = sql.OpenDB(connector)
161		28✔
162	} else {	28✔
163	db, err = sql.Open("sqlserver", filteredURL)	28✔
UNCOV 164	if err != nil {	×
165	return nil, err	×
166	}
167	}
168		32✔
169	migrationsTable := purl.Query().Get("x-migrations-table")	32✔
170		32✔
171	px, err := WithInstance(db, &Config{	32✔
172	DatabaseName: purl.Path,	32✔
173	MigrationsTable: migrationsTable,	32✔
174	})	32✔
175		40✔
176	if err != nil {	8✔
177	return nil, err	8✔
178	}
179		24✔
180	return px, nil
181	}
182
183	// Close the database connection	20✔
184	func (ss *SQLServer) Close() error {	20✔
185	connErr := ss.conn.Close()	20✔
186	dbErr := ss.db.Close()	20✔
UNCOV 187	if connErr != nil \|\| dbErr != nil {	×
188	return fmt.Errorf("conn: %v, db: %v", connErr, dbErr)	×
189	}	20✔
190	return nil
191	}
192
193	// Lock creates an advisory local on the database to prevent multiple migrations from running at the same time.	76✔
194	func (ss *SQLServer) Lock() error {	140✔
195	return database.CasRestoreOnErr(&ss.isLocked, false, true, database.ErrLocked, func() error {	64✔
196	aid, err := database.GenerateAdvisoryLockId(ss.config.DatabaseName, ss.config.SchemaName)	64✔
UNCOV 197	if err != nil {	×
198	return err	×
199	}
200
201	// This will block until the lock is acquired.
202	// MS Docs: sp_getapplock: https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-getapplock-transact-sql?view=sql-server-2017	64✔
203	query := `	64✔
204	DECLARE @lockResult int;	64✔
205	EXEC @lockResult = sp_getapplock @Resource = @p1, @LockMode = 'Exclusive', @LockOwner = 'Session', @LockTimeout = -1;	64✔
206	SELECT @lockResult;`	64✔
207		64✔
208	var status int	128✔
209	if err = ss.conn.QueryRowContext(context.Background(), query, aid).Scan(&status); err == nil && status > -1 {	64✔
210	return nil	64✔
UNCOV 211	} else if err != nil {	×
212	return &database.Error{OrigErr: err, Err: "try lock failed", Query: []byte(query)}	×
213	} else {	×
214	errorDescription, ok := lockErrorMap[status]	×
215	if !ok {	×
216	errorDescription = "Unknown error"	×
217	}	×
218	return &database.Error{Err: fmt.Sprintf("try lock failed with error %v: %v", status, errorDescription), Query: []byte(query)}
219	}
220	})
221	}
222
223	// Unlock froms the migration lock from the database	64✔
224	func (ss *SQLServer) Unlock() error {	128✔
225	return database.CasRestoreOnErr(&ss.isLocked, true, false, database.ErrNotLocked, func() error {	64✔
226	aid, err := database.GenerateAdvisoryLockId(ss.config.DatabaseName, ss.config.SchemaName)	64✔
UNCOV 227	if err != nil {	×
228	return err	×
229	}
230
231	// MS Docs: sp_releaseapplock: https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-releaseapplock-transact-sql?view=sql-server-2017	64✔
232	query := `EXEC sp_releaseapplock @Resource = @p1, @LockOwner = 'Session'`	64✔
UNCOV 233	if _, err := ss.conn.ExecContext(context.Background(), query, aid); err != nil {	×
234	return &database.Error{OrigErr: err, Query: []byte(query)}	×
235	}
236		64✔
237	return nil
238	})
239	}
240
241	// Run the migrations for the database	56✔
242	func (ss *SQLServer) Run(migration io.Reader) error {	56✔
243	migr, err := io.ReadAll(migration)	56✔
UNCOV 244	if err != nil {	×
245	return err	×
246	}
247
248	// run migration	56✔
249	query := string(migr[:])	60✔
250	if _, err := ss.conn.ExecContext(context.Background(), query); err != nil {	8✔
251	if msErr, ok := err.(mssql.Error); ok {	4✔
252	message := fmt.Sprintf("migration failed: %s", msErr.Message)	4✔
UNCOV 253	if msErr.ProcName != "" {	×
254	message = fmt.Sprintf("%s (proc name %s)", msErr.Message, msErr.ProcName)	×
255	}	4✔
256	return database.Error{OrigErr: err, Err: message, Query: migr, Line: uint(msErr.LineNo)}
UNCOV 257	}	×
258	return database.Error{OrigErr: err, Err: "migration failed", Query: migr}
259	}
260		52✔
261	return nil
262	}
263
264	// SetVersion for the current database	144✔
265	func (ss *SQLServer) SetVersion(version int, dirty bool) error {	144✔
266		144✔
267	tx, err := ss.conn.BeginTx(context.Background(), &sql.TxOptions{})	144✔
UNCOV 268	if err != nil {	×
269	return &database.Error{OrigErr: err, Err: "transaction start failed"}	×
270	}
271		144✔
272	query := `TRUNCATE TABLE ` + ss.getMigrationTable()	144✔
UNCOV 273	if _, err := tx.Exec(query); err != nil {	×
274	if errRollback := tx.Rollback(); errRollback != nil {	×
275	err = multierror.Append(err, errRollback)	×
276	}	×
277	return &database.Error{OrigErr: err, Query: []byte(query)}
278	}
279
280	// Also re-write the schema version for nil dirty versions to prevent
281	// empty schema version for failed down migration on the first migration
282	// See: https://github.com/golang-migrate/migrate/issues/330	276✔
283	if version >= 0 \|\| (version == database.NilVersion && dirty) {	132✔
284	var dirtyBit int	204✔
285	if dirty {	72✔
286	dirtyBit = 1	72✔
287	}	132✔
288	query = `INSERT INTO ` + ss.getMigrationTable() + ` (version, dirty) VALUES (@p1, @p2)`	132✔
UNCOV 289	if _, err := tx.Exec(query, version, dirtyBit); err != nil {	×
290	if errRollback := tx.Rollback(); errRollback != nil {	×
291	err = multierror.Append(err, errRollback)	×
292	}	×
293	return &database.Error{OrigErr: err, Query: []byte(query)}
294	}
295	}
296		144✔
UNCOV 297	if err := tx.Commit(); err != nil {	×
298	return &database.Error{OrigErr: err, Err: "transaction commit failed"}	×
299	}
300		144✔
301	return nil
302	}
303
304	// Version of the current database state	88✔
305	func (ss *SQLServer) Version() (version int, dirty bool, err error) {	88✔
306	query := `SELECT TOP 1 version, dirty FROM ` + ss.getMigrationTable()	88✔
307	err = ss.conn.QueryRowContext(context.Background(), query).Scan(&version, &dirty)	88✔
308	switch {	28✔
309	case err == sql.ErrNoRows:	28✔
310	return database.NilVersion, false, nil
UNCOV 311		×
312	case err != nil:	×
313	// FIXME: convert to MSSQL error	×
314	return 0, false, &database.Error{OrigErr: err, Query: []byte(query)}
315		60✔
316	default:	60✔
317	return version, dirty, nil
318	}
319	}
320
321	// Drop all tables from the database.	16✔
322	func (ss *SQLServer) Drop() error {	16✔
323		16✔
324	// drop all referential integrity constraints	16✔
325	query := `	16✔
326	DECLARE @Sql NVARCHAR(500) DECLARE @Cursor CURSOR	16✔
327		16✔
328	SET @Cursor = CURSOR FAST_FORWARD FOR	16✔
329	SELECT DISTINCT sql = 'ALTER TABLE [' + tc2.TABLE_NAME + '] DROP [' + rc1.CONSTRAINT_NAME + ']'	16✔
330	FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc1	16✔
331	LEFT JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc2 ON tc2.CONSTRAINT_NAME =rc1.CONSTRAINT_NAME	16✔
332		16✔
333	OPEN @Cursor FETCH NEXT FROM @Cursor INTO @Sql	16✔
334		16✔
335	WHILE (@@FETCH_STATUS = 0)	16✔
336	BEGIN	16✔
337	Exec sp_executesql @Sql	16✔
338	FETCH NEXT FROM @Cursor INTO @Sql	16✔
339	END	16✔
340		16✔
341	CLOSE @Cursor DEALLOCATE @Cursor`	16✔
342		16✔
UNCOV 343	if _, err := ss.conn.ExecContext(context.Background(), query); err != nil {	×
344	return &database.Error{OrigErr: err, Query: []byte(query)}	×
345	}
346
347	// drop the tables	16✔
348	query = `EXEC sp_MSforeachtable 'DROP TABLE ?'`	16✔
UNCOV 349	if _, err := ss.conn.ExecContext(context.Background(), query); err != nil {	×
350	return &database.Error{OrigErr: err, Query: []byte(query)}	×
351	}
352		16✔
353	return nil
354	}
355		24✔
356	func (ss *SQLServer) ensureVersionTable() (err error) {	24✔
UNCOV 357	if err = ss.Lock(); err != nil {	×
358	return err	×
359	}
360		48✔
361	defer func() {	24✔
UNCOV 362	if e := ss.Unlock(); e != nil {	×
363	if err == nil {	×
364	err = e	×
365	} else {	×
366	err = multierror.Append(err, e)	×
367	}
368	}
369	}()
370		24✔
371	query := `IF NOT EXISTS	24✔
372	(SELECT *	24✔
373	FROM sysobjects	24✔
374	WHERE id = object_id(N'` + ss.getMigrationTable() + `')	24✔
375	AND OBJECTPROPERTY(id, N'IsUserTable') = 1	24✔
376	)	24✔
377	CREATE TABLE ` + ss.getMigrationTable() + ` ( version BIGINT PRIMARY KEY NOT NULL, dirty BIT NOT NULL );`	24✔
378		24✔
UNCOV 379	if _, err = ss.conn.ExecContext(context.Background(), query); err != nil {	×
380	return &database.Error{OrigErr: err, Query: []byte(query)}	×
381	}
382		24✔
383	return nil
384	}
385		412✔
386	func (ss *SQLServer) getMigrationTable() string {	412✔
387	return fmt.Sprintf("[%s].[%s]", ss.config.SchemaName, ss.config.MigrationsTable)	412✔
388	}
389		4✔
390	func getMSITokenProvider(resource string) (func() (string, error), error) {	4✔
391	msi, err := adal.NewServicePrincipalTokenFromManagedIdentity(resource, nil)	4✔
UNCOV 392	if err != nil {	×
393	return nil, err	×
394	}
395		8✔
396	return func() (string, error) {	4✔
397	err := msi.EnsureFresh()	8✔
398	if err != nil {	4✔
399	return "", err	4✔
UNCOV 400	}	×
401	token := msi.OAuthToken()	×
402	return token, nil
403	}, nil
404	}
405
406	// The sql server resource can change across clouds so get it
407	// dynamically based on the server uri.
408	// ex. <server name>.database.windows.net -> https://database.windows.net	4✔
409	func getAADResourceFromServerUri(purl *nurl.URL) string {	4✔
410	return fmt.Sprintf("%s%s", "https://", strings.Join(strings.Split(purl.Hostname(), ".")[1:], "."))	4✔
411	}

golang-migrate / migrate / 17178144630

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous