5186575159

pending completion

Build # 5186575159

Build Type

Pull #932

github

Committed by

longit644

Commit Message

Add Golang function as a source of migration

Pull Request Pull Request #932: Add Golang function as a source of migration

Run Details

247 of 367 new or added lines in 32 files covered. (67.3%)

44 existing lines in 5 files now uncovered.

4217 of 7234 relevant lines covered (58.29%)

61.49 hits per line

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

65.0

/database/sqlite/sqlite.go

package sqlite

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

        "go.uber.org/atomic"

        "github.com/golang-migrate/migrate/v4"
        "github.com/golang-migrate/migrate/v4/database"
        "github.com/golang-migrate/migrate/v4/source"
        "github.com/hashicorp/go-multierror"
        _ "modernc.org/sqlite"
)

func init() {
        database.Register("sqlite", &Sqlite{})
}

var DefaultMigrationsTable = "schema_migrations"
var (
        ErrDatabaseDirty  = fmt.Errorf("database is dirty")
        ErrNilConfig      = fmt.Errorf("no config")
        ErrNoDatabaseName = fmt.Errorf("no database name")
)

type Config struct {
        MigrationsTable string
        DatabaseName    string
        NoTxWrap        bool
}

type Sqlite struct {
        db       *sql.DB
        isLocked atomic.Bool

        config *Config
}

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 len(config.MigrationsTable) == 0 {
                config.MigrationsTable = DefaultMigrationsTable
        }

        mx := &Sqlite{
                db:     instance,
                config: config,
        }
        if err := mx.ensureVersionTable(); err != nil {
                return nil, err
        }
        return mx, nil
}

// ensureVersionTable checks if versions table exists and, if not, creates it.
// Note that this function locks the database, which deviates from the usual
// convention of "caller locks" in the Sqlite type.
func (s *Sqlite) ensureVersionTable() (err error) {
        if err = s.Lock(); err != nil {
                return err
        }

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

        query := fmt.Sprintf(`
        CREATE TABLE IF NOT EXISTS %s (version uint64,dirty bool);
  CREATE UNIQUE INDEX IF NOT EXISTS version_unique ON %s (version);
  `, s.config.MigrationsTable, s.config.MigrationsTable)

        if _, err := s.db.Exec(query); err != nil {
                return err
        }
        return nil
}

func (s *Sqlite) Open(url string) (database.Driver, error) {
        purl, err := nurl.Parse(url)
        if err != nil {
                return nil, err
        }
        dbfile := strings.Replace(migrate.FilterCustomQuery(purl).String(), "sqlite://", "", 1)
        db, err := sql.Open("sqlite", dbfile)
        if err != nil {
                return nil, err
        }

        qv := purl.Query()

        migrationsTable := qv.Get("x-migrations-table")
        if len(migrationsTable) == 0 {
                migrationsTable = DefaultMigrationsTable
        }

        noTxWrap := false
        if v := qv.Get("x-no-tx-wrap"); v != "" {
                noTxWrap, err = strconv.ParseBool(v)
                if err != nil {
                        return nil, fmt.Errorf("x-no-tx-wrap: %s", err)
                }
        }

        mx, err := WithInstance(db, &Config{
                DatabaseName:    purl.Path,
                MigrationsTable: migrationsTable,
                NoTxWrap:        noTxWrap,
        })
        if err != nil {
                return nil, err
        }
        return mx, nil
}

func (s *Sqlite) Close() error {
        return s.db.Close()
}

func (s *Sqlite) Drop() (err error) {
        query := `SELECT name FROM sqlite_master WHERE type = 'table';`
        tables, err := s.db.Query(query)
        if err != nil {
                return &database.Error{OrigErr: err, Query: []byte(query)}
        }
        defer func() {
                if errClose := tables.Close(); errClose != nil {
                        err = multierror.Append(err, errClose)
                }
        }()

        tableNames := make([]string, 0)
        for tables.Next() {
                var tableName string
                if err := tables.Scan(&tableName); err != nil {
                        return err
                }
                if len(tableName) > 0 {
                        tableNames = append(tableNames, tableName)
                }
        }
        if err := tables.Err(); err != nil {
                return &database.Error{OrigErr: err, Query: []byte(query)}
        }

        if len(tableNames) > 0 {
                for _, t := range tableNames {
                        query := "DROP TABLE " + t
                        err = s.executeQuery(query)
                        if err != nil {
                                return &database.Error{OrigErr: err, Query: []byte(query)}
                        }
                }
                query := "VACUUM"
                _, err = s.db.Query(query)
                if err != nil {
                        return &database.Error{OrigErr: err, Query: []byte(query)}
                }
        }

        return nil
}

func (s *Sqlite) Lock() error {
        if !s.isLocked.CAS(false, true) {
                return database.ErrLocked
        }
        return nil
}

func (s *Sqlite) Unlock() error {
        if !s.isLocked.CAS(true, false) {
                return database.ErrNotLocked
        }
        return nil
}

func (s *Sqlite) Run(migration io.Reader) error {
        migr, err := io.ReadAll(migration)
        if err != nil {
                return err
        }
        query := string(migr[:])

        if s.config.NoTxWrap {
                return s.executeQueryNoTx(query)
        }
        return s.executeQuery(query)
}

func (s *Sqlite) executeQuery(query string) error {
        tx, err := s.db.Begin()
        if err != nil {
                return &database.Error{OrigErr: err, Err: "transaction start failed"}
        }
        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)}
        }
        if err := tx.Commit(); err != nil {
                return &database.Error{OrigErr: err, Err: "transaction commit failed"}
        }
        return nil
}

func (s *Sqlite) executeQueryNoTx(query string) error {
        if _, err := s.db.Exec(query); err != nil {
                return &database.Error{OrigErr: err, Query: []byte(query)}
        }
        return nil
}

func (s *Sqlite) SetVersion(version int, dirty bool) error {
        tx, err := s.db.Begin()
        if err != nil {
                return &database.Error{OrigErr: err, Err: "transaction start failed"}
        }

        query := "DELETE FROM " + s.config.MigrationsTable
        if _, err := tx.Exec(query); err != nil {
                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) {
                query := fmt.Sprintf(`INSERT INTO %s (version, dirty) VALUES (?, ?)`, s.config.MigrationsTable)
                if _, err := tx.Exec(query, version, dirty); 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
}

func (s *Sqlite) Version() (version int, dirty bool, err error) {
        query := "SELECT version, dirty FROM " + s.config.MigrationsTable + " LIMIT 1"
        err = s.db.QueryRow(query).Scan(&version, &dirty)
        if err != nil {
                return database.NilVersion, false, nil
        }
        return version, dirty, nil
}

func (s *Sqlite) Exec(e source.Executor) error {
        return e.Execute(s.db)
}

1	package sqlite
2
3	import (
4	"database/sql"
5	"fmt"
6	"io"
7	nurl "net/url"
8	"strconv"
9	"strings"
10
11	"go.uber.org/atomic"
12
13	"github.com/golang-migrate/migrate/v4"
14	"github.com/golang-migrate/migrate/v4/database"
15	"github.com/golang-migrate/migrate/v4/source"
16	"github.com/hashicorp/go-multierror"
17	_ "modernc.org/sqlite"
18	)
19
20	func init() {	2✔
21	database.Register("sqlite", &Sqlite{})	2✔
22	}	2✔
23
24	var DefaultMigrationsTable = "schema_migrations"
25	var (
26	ErrDatabaseDirty = fmt.Errorf("database is dirty")
27	ErrNilConfig = fmt.Errorf("no config")
28	ErrNoDatabaseName = fmt.Errorf("no database name")
29	)
30
31	type Config struct {
32	MigrationsTable string
33	DatabaseName string
34	NoTxWrap bool
35	}
36
37	type Sqlite struct {
38	db *sql.DB
39	isLocked atomic.Bool
40
41	config *Config
42	}
43
44	func WithInstance(instance sql.DB, config Config) (database.Driver, error) {	10✔
45	if config == nil {	10✔
46	return nil, ErrNilConfig	×
47	}	×
48
49	if err := instance.Ping(); err != nil {	10✔
50	return nil, err	×
51	}	×
52
53	if len(config.MigrationsTable) == 0 {	12✔
54	config.MigrationsTable = DefaultMigrationsTable	2✔
55	}	2✔
56
57	mx := &Sqlite{	10✔
58	db: instance,	10✔
59	config: config,	10✔
60	}	10✔
61	if err := mx.ensureVersionTable(); err != nil {	10✔
62	return nil, err	×
63	}	×
64	return mx, nil	10✔
65	}
66
67	// ensureVersionTable checks if versions table exists and, if not, creates it.
68	// Note that this function locks the database, which deviates from the usual
69	// convention of "caller locks" in the Sqlite type.
70	func (s *Sqlite) ensureVersionTable() (err error) {	10✔
71	if err = s.Lock(); err != nil {	10✔
72	return err	×
73	}	×
74
75	defer func() {	20✔
76	if e := s.Unlock(); e != nil {	10✔
77	if err == nil {	×
78	err = e	×
79	} else {	×
80	err = multierror.Append(err, e)	×
81	}	×
82	}
83	}()
84
85	query := fmt.Sprintf(`	10✔
86	CREATE TABLE IF NOT EXISTS %s (version uint64,dirty bool);	10✔
87	CREATE UNIQUE INDEX IF NOT EXISTS version_unique ON %s (version);	10✔
88	`, s.config.MigrationsTable, s.config.MigrationsTable)	10✔
89		10✔
90	if _, err := s.db.Exec(query); err != nil {	10✔
91	return err	×
92	}	×
93	return nil	10✔
94	}
95
96	func (s *Sqlite) Open(url string) (database.Driver, error) {	8✔
97	purl, err := nurl.Parse(url)	8✔
98	if err != nil {	8✔
99	return nil, err	×
100	}	×
101	dbfile := strings.Replace(migrate.FilterCustomQuery(purl).String(), "sqlite://", "", 1)	8✔
102	db, err := sql.Open("sqlite", dbfile)	8✔
103	if err != nil {	8✔
104	return nil, err	×
105	}	×
106
107	qv := purl.Query()	8✔
108		8✔
109	migrationsTable := qv.Get("x-migrations-table")	8✔
110	if len(migrationsTable) == 0 {	16✔
111	migrationsTable = DefaultMigrationsTable	8✔
112	}	8✔
113
114	noTxWrap := false	8✔
115	if v := qv.Get("x-no-tx-wrap"); v != "" {	12✔
116	noTxWrap, err = strconv.ParseBool(v)	4✔
117	if err != nil {	6✔
118	return nil, fmt.Errorf("x-no-tx-wrap: %s", err)	2✔
119	}	2✔
120	}
121
122	mx, err := WithInstance(db, &Config{	6✔
123	DatabaseName: purl.Path,	6✔
124	MigrationsTable: migrationsTable,	6✔
125	NoTxWrap: noTxWrap,	6✔
126	})	6✔
127	if err != nil {	6✔
128	return nil, err	×
129	}	×
130	return mx, nil	6✔
131	}
132
NEW 133	func (s *Sqlite) Close() error {	×
NEW 134	return s.db.Close()	×
UNCOV 135	}	×
136
137	func (s *Sqlite) Drop() (err error) {	8✔
138	query := `SELECT name FROM sqlite_master WHERE type = 'table';`	8✔
139	tables, err := s.db.Query(query)	8✔
140	if err != nil {	8✔
141	return &database.Error{OrigErr: err, Query: []byte(query)}	×
142	}	×
143	defer func() {	16✔
144	if errClose := tables.Close(); errClose != nil {	8✔
145	err = multierror.Append(err, errClose)	×
146	}	×
147	}()
148
149	tableNames := make([]string, 0)	8✔
150	for tables.Next() {	24✔
151	var tableName string	16✔
152	if err := tables.Scan(&tableName); err != nil {	16✔
153	return err	×
154	}	×
155	if len(tableName) > 0 {	32✔
156	tableNames = append(tableNames, tableName)	16✔
157	}	16✔
158	}
159	if err := tables.Err(); err != nil {	8✔
160	return &database.Error{OrigErr: err, Query: []byte(query)}	×
161	}	×
162
163	if len(tableNames) > 0 {	16✔
164	for _, t := range tableNames {	24✔
165	query := "DROP TABLE " + t	16✔
166	err = s.executeQuery(query)	16✔
167	if err != nil {	16✔
168	return &database.Error{OrigErr: err, Query: []byte(query)}	×
169	}	×
170	}
171	query := "VACUUM"	8✔
172	_, err = s.db.Query(query)	8✔
173	if err != nil {	8✔
174	return &database.Error{OrigErr: err, Query: []byte(query)}	×
175	}	×
176	}
177
178	return nil	8✔
179	}
180
181	func (s *Sqlite) Lock() error {	34✔
182	if !s.isLocked.CAS(false, true) {	40✔
183	return database.ErrLocked	6✔
184	}	6✔
185	return nil	28✔
186	}
187
188	func (s *Sqlite) Unlock() error {	28✔
189	if !s.isLocked.CAS(true, false) {	28✔
190	return database.ErrNotLocked	×
191	}	×
192	return nil	28✔
193	}
194
195	func (s *Sqlite) Run(migration io.Reader) error {	14✔
196	migr, err := io.ReadAll(migration)	14✔
197	if err != nil {	14✔
198	return err	×
199	}	×
200	query := string(migr[:])	14✔
201		14✔
202	if s.config.NoTxWrap {	16✔
203	return s.executeQueryNoTx(query)	2✔
204	}	2✔
205	return s.executeQuery(query)	12✔
206	}
207
208	func (s *Sqlite) executeQuery(query string) error {	28✔
209	tx, err := s.db.Begin()	28✔
210	if err != nil {	28✔
211	return &database.Error{OrigErr: err, Err: "transaction start failed"}	×
212	}	×
213	if _, err := tx.Exec(query); err != nil {	28✔
214	if errRollback := tx.Rollback(); errRollback != nil {	×
215	err = multierror.Append(err, errRollback)	×
216	}	×
217	return &database.Error{OrigErr: err, Query: []byte(query)}	×
218	}
219	if err := tx.Commit(); err != nil {	28✔
220	return &database.Error{OrigErr: err, Err: "transaction commit failed"}	×
221	}	×
222	return nil	28✔
223	}
224
225	func (s *Sqlite) executeQueryNoTx(query string) error {	2✔
226	if _, err := s.db.Exec(query); err != nil {	2✔
227	return &database.Error{OrigErr: err, Query: []byte(query)}	×
228	}	×
229	return nil	2✔
230	}
231
232	func (s *Sqlite) SetVersion(version int, dirty bool) error {	52✔
233	tx, err := s.db.Begin()	52✔
234	if err != nil {	52✔
235	return &database.Error{OrigErr: err, Err: "transaction start failed"}	×
236	}	×
237
238	query := "DELETE FROM " + s.config.MigrationsTable	52✔
239	if _, err := tx.Exec(query); err != nil {	52✔
240	return &database.Error{OrigErr: err, Query: []byte(query)}	×
241	}	×
242
243	// Also re-write the schema version for nil dirty versions to prevent
244	// empty schema version for failed down migration on the first migration
245	// See: https://github.com/golang-migrate/migrate/issues/330
246	if version >= 0 \|\| (version == database.NilVersion && dirty) {	98✔
247	query := fmt.Sprintf(`INSERT INTO %s (version, dirty) VALUES (?, ?)`, s.config.MigrationsTable)	46✔
248	if _, err := tx.Exec(query, version, dirty); err != nil {	46✔
249	if errRollback := tx.Rollback(); errRollback != nil {	×
250	err = multierror.Append(err, errRollback)	×
251	}	×
252	return &database.Error{OrigErr: err, Query: []byte(query)}	×
253	}
254	}
255
256	if err := tx.Commit(); err != nil {	52✔
257	return &database.Error{OrigErr: err, Err: "transaction commit failed"}	×
258	}	×
259
260	return nil	52✔
261	}
262
263	func (s *Sqlite) Version() (version int, dirty bool, err error) {	46✔
264	query := "SELECT version, dirty FROM " + s.config.MigrationsTable + " LIMIT 1"	46✔
265	err = s.db.QueryRow(query).Scan(&version, &dirty)	46✔
266	if err != nil {	62✔
267	return database.NilVersion, false, nil	16✔
268	}	16✔
269	return version, dirty, nil	30✔
270	}
271
NEW 272	func (s *Sqlite) Exec(e source.Executor) error {	×
NEW 273	return e.Execute(s.db)	×
NEW 274	}	×

golang-migrate / migrate / 5186575159

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