139 lines
3.2 KiB
Go
139 lines
3.2 KiB
Go
package db
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"database/sql"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
|
|
_ "modernc.org/sqlite"
|
|
)
|
|
|
|
type DB struct {
|
|
*sql.DB
|
|
}
|
|
|
|
func (d *DB) SQLDB() *sql.DB {
|
|
return d.DB
|
|
}
|
|
|
|
func Open(dbPath string) (*DB, error) {
|
|
if err := os.MkdirAll(filepath.Dir(dbPath), 0700); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
db, err := sql.Open("sqlite", dbPath+"?_pragma=busy_timeout(5000)&_pragma=journal_mode(WAL)")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("opening db: %w", err)
|
|
}
|
|
|
|
if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
|
|
db.Close()
|
|
return nil, fmt.Errorf("enabling foreign_keys: %w", err)
|
|
}
|
|
|
|
return &DB{db}, nil
|
|
}
|
|
|
|
func (db *DB) Close() error {
|
|
return db.DB.Close()
|
|
}
|
|
|
|
func (db *DB) RunMigrations() error {
|
|
return db.runMigrationsInternal(migrationsFS, "migrations")
|
|
}
|
|
|
|
func (db *DB) runMigrationsInternal(mfs embedFS, migrationsRoot string) error {
|
|
entries, err := mfs.ReadDir(migrationsRoot)
|
|
if err != nil {
|
|
return fmt.Errorf("reading migrations dir: %w", err)
|
|
}
|
|
|
|
var names []string
|
|
for _, e := range entries {
|
|
if !e.IsDir() && strings.HasSuffix(e.Name(), ".sql") {
|
|
names = append(names, e.Name())
|
|
}
|
|
}
|
|
sort.Strings(names)
|
|
|
|
if _, err := db.Exec(`
|
|
CREATE TABLE IF NOT EXISTS schema_migrations (
|
|
version TEXT PRIMARY KEY,
|
|
checksum TEXT,
|
|
applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
|
|
)
|
|
`); err != nil {
|
|
return fmt.Errorf("creating schema_migrations table: %w", err)
|
|
}
|
|
|
|
for _, name := range names {
|
|
var storedChecksum string
|
|
row := db.QueryRow("SELECT checksum FROM schema_migrations WHERE version = ?", name)
|
|
if err := row.Scan(&storedChecksum); err == nil && storedChecksum != "" {
|
|
continue
|
|
}
|
|
|
|
data, err := mfs.ReadFile(filepath.Join(migrationsRoot, name))
|
|
if err != nil {
|
|
return fmt.Errorf("reading migration %s: %w", name, err)
|
|
}
|
|
|
|
checksum := sha256.Sum256(data)
|
|
checksumHex := hex.EncodeToString(checksum[:])
|
|
|
|
tx, err := db.Begin()
|
|
if err != nil {
|
|
return fmt.Errorf("starting transaction for migration %s: %w", name, err)
|
|
}
|
|
|
|
if _, err := tx.Exec(string(data)); err != nil {
|
|
tx.Rollback()
|
|
return fmt.Errorf("applying migration %s: %w", name, err)
|
|
}
|
|
|
|
var insertSQL string
|
|
var insertArgs []interface{}
|
|
insertArgs = append(insertArgs, name)
|
|
hasChecksum := false
|
|
rows, _ := tx.Query("PRAGMA table_info(schema_migrations)")
|
|
if rows != nil {
|
|
for rows.Next() {
|
|
var cid int
|
|
var cname string
|
|
rows.Scan(&cid, &cname, new(string), new(int), new(interface{}), new(int))
|
|
if cname == "checksum" {
|
|
hasChecksum = true
|
|
}
|
|
}
|
|
rows.Close()
|
|
}
|
|
if hasChecksum {
|
|
insertSQL = "INSERT INTO schema_migrations (version, checksum) VALUES (?, ?)"
|
|
insertArgs = append(insertArgs, checksumHex)
|
|
} else {
|
|
insertSQL = "INSERT INTO schema_migrations (version) VALUES (?)"
|
|
}
|
|
|
|
if _, err := tx.Exec(insertSQL, insertArgs...); err != nil {
|
|
tx.Rollback()
|
|
return fmt.Errorf("recording migration %s: %w", name, err)
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return fmt.Errorf("committing migration %s: %w", name, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type embedFS interface {
|
|
ReadDir(name string) ([]os.DirEntry, error)
|
|
ReadFile(name string) ([]byte, error)
|
|
}
|