19729155206

Committed 27 Nov 2025 07:58AM UTC coverage: 54.432% (+0.4%) from 54.037%

Build # 19729155206

Build Type

Pull #1322

github

Committed by

leonklingele

Commit Message

chore: bring back unused util.go file as removing it is a breaking change

Pull Request Pull Request #1322: chore: remove dependency on "hashicorp/go-multierror"

Run Details

1 of 68 new or added lines in 22 files covered. (1.47%)

19 existing lines in 2 files now uncovered.

4378 of 8043 relevant lines covered (54.43%)

48.59 hits per line

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

71.26

/database/sqlserver/sqlserver.go

package sqlserver

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

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

golang-migrate / migrate / 19729155206

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