up

internal/db/mysql.go

@@ -0,0 +1,242 @@
+package db
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+	"time"
+
+	mysqldriver "github.com/go-sql-driver/mysql"
+)
+
+// ── SQLite → MySQL schema translation ──────────────────────────────────
+//
+// OpsLog's migrations are authored in SQLite dialect (the default backend).
+// For the shared-MySQL backend we translate that DDL on the fly rather than
+// maintaining a second set of migration files, so the two backends can never
+// drift apart. The translation is deliberately narrow — it only rewrites the
+// SQLite-isms that actually appear in our migrations:
+//
+//   - INTEGER PRIMARY KEY [AUTOINCREMENT]  → BIGINT AUTO_INCREMENT PRIMARY KEY
+//   - bare INTEGER                          → BIGINT (so FK child/parent types match)
+//   - DEFAULT (strftime(... 'now'))         → DEFAULT '' (timestamps come from Go)
+//   - TEXT                                  → VARCHAR(255), except a few free-text
+//                                             columns that stay TEXT/LONGTEXT
+//   - reserved column `key`                 → backticked
+//   - CREATE INDEX IF NOT EXISTS            → CREATE INDEX (MySQL has no IF NOT EXISTS)
+//
+// REAL is left as-is (MySQL accepts it as an alias for DOUBLE). CREATE/DROP
+// TABLE IF [NOT] EXISTS, RENAME TO, INSERT…SELECT, CHECK(...) and foreign keys
+// are all valid MySQL as written.
+
+var (
+	reStrftimeDefault = regexp.MustCompile(`\(strftime\('%Y-%m-%dT%H:%M:%fZ',\s*'now'\)\)`)
+	reBareInteger     = regexp.MustCompile(`\bINTEGER\b`)
+	reColText         = regexp.MustCompile(`(\w+)\s+TEXT\b`)
+	reKeyColumn       = regexp.MustCompile(`(?m)^(\s*)key\b`)
+)
+
+// MySQL's InnoDB row-size limit is 65535 bytes (excluding off-page TEXT/BLOB).
+// The qso table has ~150 columns, so making them all VARCHAR(255) (1020 bytes
+// each in utf8mb4) overflows the row. We therefore emit TEXT (stored off-page,
+// ~20 bytes in-row) for the bulk of columns, and VARCHAR only where a column
+// actually needs in-row storage: it's indexed, a primary key, or carries a
+// DEFAULT (TEXT can't hold a literal default in MySQL).
+
+// varcharColumns must be VARCHAR because they're indexed or part of a primary
+// key declared on a separate line (so the DEFAULT/PRIMARY-KEY line heuristic
+// below can't catch them). MySQL can't index a TEXT column without a prefix
+// length. Keyed by column name (a name may repeat across tables — harmless).
+var varcharColumns = map[string]bool{
+	// qso indexes (0001, 0003, 0019)
+	"callsign": true, "qso_date": true, "band": true, "mode": true,
+	"grid": true, "station_callsign": true, "state": true, "contest_id": true,
+	"sat_name": true, "prop_mode": true, "sig": true, "wwff_ref": true, "skcc": true,
+	// integrations_udp index (0011)
+	"direction": true,
+	// award_references composite primary key (0017)
+	"award_code": true, "ref_code": true,
+}
+
+// longTextColumns override the default TEXT with a bigger type where the
+// content can be large (a full QSL-template document).
+var longTextColumns = map[string]string{
+	"json": "LONGTEXT",
+}
+
+// mysqlDDL rewrites a SQLite DDL/DML statement (or multi-statement migration
+// file) into the MySQL dialect. See the package note above for the rules.
+func mysqlDDL(stmt string) string {
+	s := stmt
+	// MySQL has no IF NOT EXISTS for CREATE INDEX (migrations run once anyway).
+	s = strings.ReplaceAll(s, "CREATE INDEX IF NOT EXISTS", "CREATE INDEX")
+	// Auto-increment primary keys. Both the AUTOINCREMENT form and the bare
+	// "INTEGER PRIMARY KEY" (SQLite rowid alias) must become AUTO_INCREMENT so
+	// inserts that omit the id still get one.
+	s = strings.ReplaceAll(s, "INTEGER PRIMARY KEY AUTOINCREMENT", "BIGINT AUTO_INCREMENT PRIMARY KEY")
+	s = strings.ReplaceAll(s, "INTEGER PRIMARY KEY", "BIGINT AUTO_INCREMENT PRIMARY KEY")
+	// Timestamp defaults: Go supplies ISO strings, so drop the SQLite function
+	// default (TEXT/VARCHAR can't carry it in MySQL anyway).
+	s = reStrftimeDefault.ReplaceAllString(s, "''")
+	// Remaining INTEGER columns → BIGINT so foreign-key parent/child types match.
+	s = reBareInteger.ReplaceAllString(s, "BIGINT")
+	// TEXT columns → TEXT (off-page) by default, VARCHAR(255) only when indexed,
+	// a primary key, or default-bearing — keeping the row under MySQL's limit.
+	s = translateTextColumns(s)
+	// `key` is a MySQL reserved word — backtick the settings column declaration.
+	s = reKeyColumn.ReplaceAllString(s, "$1`key`")
+	return s
+}
+
+// translateTextColumns rewrites each "<col> TEXT" column declaration to the
+// right MySQL type, deciding per line so it can see whether the line carries a
+// DEFAULT or an inline PRIMARY KEY. See varcharColumns / longTextColumns.
+func translateTextColumns(s string) string {
+	lines := strings.Split(s, "\n")
+	for i, line := range lines {
+		m := reColText.FindStringSubmatchIndex(line)
+		if m == nil {
+			continue
+		}
+		col := line[m[2]:m[3]]
+		var typ string
+		switch {
+		case longTextColumns[col] != "":
+			typ = longTextColumns[col]
+		case varcharColumns[col],
+			strings.Contains(line, "DEFAULT"),
+			strings.Contains(line, "PRIMARY KEY"):
+			typ = "VARCHAR(255)"
+		default:
+			typ = "TEXT"
+		}
+		lines[i] = line[:m[0]] + col + " " + typ + line[m[1]:]
+	}
+	return strings.Join(lines, "\n")
+}
+
+// OpenMySQL opens the shared MySQL logbook, creating the database if needed,
+// then applies the (translated) embedded migrations. multiStatements is enabled
+// so multi-statement migration files run in a single Exec.
+func OpenMySQL(c MySQLConfig) (*sql.DB, error) {
+	if strings.TrimSpace(c.Host) == "" {
+		return nil, fmt.Errorf("host is required")
+	}
+	name := strings.TrimSpace(c.Database)
+	if !validDBIdent(name) {
+		return nil, fmt.Errorf("invalid database name %q (letters, digits, underscore only)", name)
+	}
+	// Ensure the database exists (connect server-level first).
+	if err := PingMySQL(c); err != nil {
+		return nil, err
+	}
+	conn, err := sql.Open("mysql", c.dsn())
+	if err != nil {
+		return nil, fmt.Errorf("open mysql: %w", err)
+	}
+	// The UI fires bursts of concurrent queries (the Preferences dialog alone
+	// loads ~8 settings in parallel, plus the grid and live cluster status). A
+	// low cap turns such a burst into a deadlock-like stall against a remote
+	// server, so keep a generous pool with idle reaping. SQLite ran uncapped.
+	conn.SetMaxOpenConns(50)
+	conn.SetMaxIdleConns(10)
+	conn.SetConnMaxIdleTime(90 * time.Second)
+	conn.SetConnMaxLifetime(5 * time.Minute)
+	if err := conn.Ping(); err != nil {
+		_ = conn.Close()
+		return nil, fmt.Errorf("connect to %s: %w", name, err)
+	}
+	// Set the dialect before migrating so the runner takes the MySQL path
+	// (per-statement, idempotent) rather than the SQLite transaction path.
+	Dialect = "mysql"
+	if err := migrate(conn, mysqlDDL); err != nil {
+		_ = conn.Close()
+		Dialect = "sqlite" // migration failed; we'll fall back to SQLite
+		return nil, err
+	}
+	return conn, nil
+}
+
+// applyMySQLMigration executes a translated migration one statement at a time.
+// MySQL has no multi-statement Exec without a special flag and auto-commits DDL,
+// so running statements individually (and tolerating "already exists" errors)
+// keeps migrations idempotent and lets a half-applied database self-heal.
+//
+// It runs on a single dedicated connection with FOREIGN_KEY_CHECKS=0, because a
+// few migrations recreate tables by DROP/RENAME in an order that trips MySQL's
+// foreign-key enforcement (SQLite is laxer). The flag is reset to 1 before the
+// connection returns to the pool, so runtime queries keep FK enforcement.
+func applyMySQLMigration(conn *sql.DB, sqlText string) error {
+	ctx := context.Background()
+	c, err := conn.Conn(ctx)
+	if err != nil {
+		return fmt.Errorf("acquire conn: %w", err)
+	}
+	defer func() {
+		_, _ = c.ExecContext(ctx, "SET FOREIGN_KEY_CHECKS=1")
+		_ = c.Close()
+	}()
+	if _, err := c.ExecContext(ctx, "SET FOREIGN_KEY_CHECKS=0"); err != nil {
+		return fmt.Errorf("disable fk checks: %w", err)
+	}
+	for _, stmt := range splitStatements(sqlText) {
+		if _, err := c.ExecContext(ctx, stmt); err != nil {
+			if isIgnorableDDLError(err) {
+				continue
+			}
+			return fmt.Errorf("statement %q: %w", firstLine(stmt), err)
+		}
+	}
+	return nil
+}
+
+// splitStatements breaks a migration file into individual SQL statements,
+// dropping full-line comments and blank fragments. Our migrations never embed
+// a ';' inside a string literal, so a simple split is safe.
+func splitStatements(sqlText string) []string {
+	var b strings.Builder
+	for _, line := range strings.Split(sqlText, "\n") {
+		if strings.HasPrefix(strings.TrimSpace(line), "--") {
+			continue
+		}
+		b.WriteString(line)
+		b.WriteByte('\n')
+	}
+	var out []string
+	for _, part := range strings.Split(b.String(), ";") {
+		if strings.TrimSpace(part) != "" {
+			out = append(out, part)
+		}
+	}
+	return out
+}
+
+func firstLine(s string) string {
+	s = strings.TrimSpace(s)
+	if i := strings.IndexByte(s, '\n'); i >= 0 {
+		return s[:i]
+	}
+	return s
+}
+
+// isIgnorableDDLError reports whether a MySQL error means the object the
+// statement creates/drops is already in the intended state — safe to skip when
+// re-applying a forward-only migration.
+func isIgnorableDDLError(err error) bool {
+	var me *mysqldriver.MySQLError
+	if !errors.As(err, &me) {
+		return false
+	}
+	switch me.Number {
+	case 1050, // ER_TABLE_EXISTS_ERROR — CREATE TABLE on an existing table
+		1051, // ER_BAD_TABLE_ERROR — DROP TABLE on a missing table
+		1060, // ER_DUP_FIELDNAME — ADD COLUMN already present
+		1061, // ER_DUP_KEYNAME — CREATE INDEX already present
+		1091: // ER_CANT_DROP_FIELD_OR_KEY — DROP of something that doesn't exist
+		return true
+	}
+	return false
+}