130 lines
3.3 KiB
Go
130 lines
3.3 KiB
Go
package db
|
|
|
|
import (
|
|
"database/sql"
|
|
"embed"
|
|
"log/slog"
|
|
"reflect"
|
|
"wnzl-snow/db/queries"
|
|
|
|
"github.com/jmoiron/sqlx"
|
|
"github.com/pressly/goose/v3"
|
|
)
|
|
|
|
//go:embed migrations/*.sql
|
|
var migrations embed.FS
|
|
|
|
type Database interface {
|
|
DB() *sqlx.DB
|
|
Queries() *queries.Queries
|
|
Logger() *slog.Logger
|
|
Close() error
|
|
}
|
|
|
|
func New(logger *slog.Logger, url string) (Database, error) {
|
|
db, err := newLocalDB(logger, url)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err = db.db.Ping(); err != nil {
|
|
return nil, err
|
|
}
|
|
return db, nil
|
|
}
|
|
|
|
// Migrate runs the migrations on the database. Assumes the database is SQLite.
|
|
func Migrate(db Database) error {
|
|
|
|
goose.SetBaseFS(migrations)
|
|
|
|
if err := goose.SetDialect("sqlite3"); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if err := goose.Up(db.DB().DB, "migrations"); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// TODO - replace with goose
|
|
/*
|
|
driver, err := sqlite3.WithInstance(db.DB(), &sqlite3.Config{})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create database driver: %w", err)
|
|
}
|
|
|
|
iofsDriver, err := iofs.New(migrations, "migrations")
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create iofs: %w", err)
|
|
}
|
|
defer iofsDriver.Close()
|
|
|
|
m, err := migrate.NewWithInstance("iofs", iofsDriver, "sqlite3", driver)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create migration: %w", err)
|
|
}
|
|
|
|
return m.Up()
|
|
*/
|
|
|
|
return nil
|
|
}
|
|
|
|
// ConvertToSQLParams is a utility function that generically converts a struct to a corresponding sqlc-generated struct
|
|
func ConvertToSQLParams(input interface{}, output interface{}) {
|
|
inputVal := reflect.ValueOf(input).Elem()
|
|
outputVal := reflect.ValueOf(output).Elem()
|
|
|
|
for i := 0; i < outputVal.NumField(); i++ {
|
|
outputField := outputVal.Field(i)
|
|
inputField := inputVal.FieldByName(outputVal.Type().Field(i).Name)
|
|
|
|
if !inputField.IsValid() || !outputField.CanSet() {
|
|
continue
|
|
}
|
|
|
|
// Handle fields of type sql.NullString, sql.NullInt64, and normal string/int64 fields
|
|
switch outputField.Type() {
|
|
case reflect.TypeOf(sql.NullString{}):
|
|
// Handle sql.NullString
|
|
if inputField.Kind() == reflect.Ptr && inputField.IsNil() {
|
|
outputField.Set(reflect.ValueOf(sql.NullString{Valid: false}))
|
|
} else {
|
|
outputField.Set(reflect.ValueOf(sql.NullString{String: inputField.String(), Valid: true}))
|
|
}
|
|
|
|
case reflect.TypeOf(sql.NullInt64{}):
|
|
// Handle sql.NullInt64
|
|
if inputField.Int() == 0 {
|
|
outputField.Set(reflect.ValueOf(sql.NullInt64{Valid: false}))
|
|
} else {
|
|
outputField.Set(reflect.ValueOf(sql.NullInt64{Int64: inputField.Int(), Valid: true}))
|
|
}
|
|
|
|
case reflect.TypeOf(sql.NullFloat64{}):
|
|
// Handle sql.NullFloat64
|
|
if inputField.Float() == 0 {
|
|
outputField.Set(reflect.ValueOf(sql.NullFloat64{Valid: false}))
|
|
} else {
|
|
outputField.Set(reflect.ValueOf(sql.NullFloat64{Float64: inputField.Float(), Valid: true}))
|
|
}
|
|
|
|
case reflect.TypeOf(""):
|
|
// Handle normal string fields
|
|
if inputField.Kind() == reflect.Ptr && inputField.IsNil() {
|
|
outputField.SetString("") // Set to empty string if input is nil
|
|
} else {
|
|
outputField.SetString(inputField.String())
|
|
}
|
|
|
|
case reflect.TypeOf(int64(0)):
|
|
// Handle normal int64 fields
|
|
outputField.SetInt(inputField.Int())
|
|
|
|
case reflect.TypeOf(float64(0)):
|
|
// Handle normal float64 fields
|
|
outputField.SetFloat(inputField.Float())
|
|
|
|
}
|
|
}
|
|
}
|