• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

golang-migrate / migrate / 19788418582

29 Nov 2025 07:37PM UTC coverage: 54.432% (+0.4%) from 54.049%
19788418582

push

github

web-flow
chore: remove dependency on "hashicorp/go-multierror" (#1322)

* feat: remove dependency on "hashicorp/go-multierror"

It seems the project has been unmainted for quite some time already,
see for example https://github.com/hashicorp/go-multierror/issues/97
and https://github.com/hashicorp/go-multierror/issues/98.
This also removes an uneccessary dependency which slims down the go.mod.

Go as of version 1.20 supports appending errors by specifying
multiple "%w" formatters in the "fmt.Errorf"[^0] function.

[^0]: https://pkg.go.dev/fmt#Errorf

* feat: use errors.Join to combine multiple errors

As an update to the previous commit 59f084ea3,
use "errors.Join"[^0] instead of multiple "%w" formatters for "fmt.Errorf".

[^0]: https://pkg.go.dev/errors#Join

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

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

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
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 ✔
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc