BREAKING: update mautrix to 0.15.x

2023-06-01 14:32:20 +00:00
parent a6b20a75ab
commit 2bdb8ca635
222 changed files with 7851 additions and 23986 deletions
--- a/vendor/maunium.net/go/mautrix/util/dbutil/connlog.go
+++ b/vendor/maunium.net/go/mautrix/util/dbutil/connlog.go
@@ -23,7 +23,7 @@ func (le *LoggingExecable) ExecContext(ctx context.Context, query string, args .
 	start := time.Now()
 	query = le.db.mutateQuery(query)
 	res, err := le.UnderlyingExecable.ExecContext(ctx, query, args...)
-	le.db.Log.QueryTiming(ctx, "Exec", query, args, -1, time.Since(start))
+	le.db.Log.QueryTiming(ctx, "Exec", query, args, -1, time.Since(start), err)
 	return res, err
 }

@@ -31,7 +31,7 @@ func (le *LoggingExecable) QueryContext(ctx context.Context, query string, args
 	start := time.Now()
 	query = le.db.mutateQuery(query)
 	rows, err := le.UnderlyingExecable.QueryContext(ctx, query, args...)
-	le.db.Log.QueryTiming(ctx, "Query", query, args, -1, time.Since(start))
+	le.db.Log.QueryTiming(ctx, "Query", query, args, -1, time.Since(start), err)
 	return &LoggingRows{
 		ctx:   ctx,
 		db:    le.db,
@@ -46,7 +46,7 @@ func (le *LoggingExecable) QueryRowContext(ctx context.Context, query string, ar
 	start := time.Now()
 	query = le.db.mutateQuery(query)
 	row := le.UnderlyingExecable.QueryRowContext(ctx, query, args...)
-	le.db.Log.QueryTiming(ctx, "QueryRow", query, args, -1, time.Since(start))
+	le.db.Log.QueryTiming(ctx, "QueryRow", query, args, -1, time.Since(start), nil)
 	return row
 }

@@ -73,7 +73,7 @@ type loggingDB struct {
 func (ld *loggingDB) BeginTx(ctx context.Context, opts *sql.TxOptions) (*LoggingTxn, error) {
 	start := time.Now()
 	tx, err := ld.db.RawDB.BeginTx(ctx, opts)
-	ld.db.Log.QueryTiming(ctx, "Begin", "", nil, -1, time.Since(start))
+	ld.db.Log.QueryTiming(ctx, "Begin", "", nil, -1, time.Since(start), err)
 	if err != nil {
 		return nil, err
 	}
@@ -81,6 +81,7 @@ func (ld *loggingDB) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Logging
 		LoggingExecable: LoggingExecable{UnderlyingExecable: tx, db: ld.db},
 		UnderlyingTx:    tx,
 		ctx:             ctx,
+		StartTime:       start,
 	}, nil
 }

@@ -92,22 +93,35 @@ type LoggingTxn struct {
 	LoggingExecable
 	UnderlyingTx *sql.Tx
 	ctx          context.Context
+
+	StartTime  time.Time
+	EndTime    time.Time
+	noTotalLog bool
 }

 func (lt *LoggingTxn) Commit() error {
 	start := time.Now()
 	err := lt.UnderlyingTx.Commit()
-	lt.db.Log.QueryTiming(lt.ctx, "Commit", "", nil, -1, time.Since(start))
+	lt.endLog()
+	lt.db.Log.QueryTiming(lt.ctx, "Commit", "", nil, -1, time.Since(start), err)
 	return err
 }

 func (lt *LoggingTxn) Rollback() error {
 	start := time.Now()
 	err := lt.UnderlyingTx.Rollback()
-	lt.db.Log.QueryTiming(lt.ctx, "Rollback", "", nil, -1, time.Since(start))
+	lt.endLog()
+	lt.db.Log.QueryTiming(lt.ctx, "Rollback", "", nil, -1, time.Since(start), err)
 	return err
 }

+func (lt *LoggingTxn) endLog() {
+	lt.EndTime = time.Now()
+	if !lt.noTotalLog {
+		lt.db.Log.QueryTiming(lt.ctx, "<Transaction>", "", nil, -1, lt.EndTime.Sub(lt.StartTime), nil)
+	}
+}
+
 type LoggingRows struct {
 	ctx   context.Context
 	db    *Database
@@ -120,7 +134,7 @@ type LoggingRows struct {

 func (lrs *LoggingRows) stopTiming() {
 	if !lrs.start.IsZero() {
-		lrs.db.Log.QueryTiming(lrs.ctx, "EndRows", lrs.query, lrs.args, lrs.nrows, time.Since(lrs.start))
+		lrs.db.Log.QueryTiming(lrs.ctx, "EndRows", lrs.query, lrs.args, lrs.nrows, time.Since(lrs.start), lrs.rs.Err())
 		lrs.start = time.Time{}
 	}
 }
--- a/vendor/maunium.net/go/mautrix/util/dbutil/database.go
+++ b/vendor/maunium.net/go/mautrix/util/dbutil/database.go
@@ -13,8 +13,6 @@ import (
 	"regexp"
 	"strings"
 	"time"
-
-	"maunium.net/go/mautrix/bridge/bridgeconfig"
 )

 type Dialect int
@@ -38,7 +36,7 @@ func (dialect Dialect) String() string {

 func ParseDialect(engine string) (Dialect, error) {
 	switch strings.ToLower(engine) {
-	case "postgres", "postgresql":
+	case "postgres", "postgresql", "pgx":
 		return Postgres, nil
 	case "sqlite3", "sqlite", "litestream", "sqlite3-fk-wal":
 		return SQLite, nil
@@ -176,7 +174,18 @@ func NewWithDialect(uri, rawDialect string) (*Database, error) {
 	return NewWithDB(db, rawDialect)
 }

-func (db *Database) Configure(cfg bridgeconfig.DatabaseConfig) error {
+type Config struct {
+	Type string `yaml:"type"`
+	URI  string `yaml:"uri"`
+
+	MaxOpenConns int `yaml:"max_open_conns"`
+	MaxIdleConns int `yaml:"max_idle_conns"`
+
+	ConnMaxIdleTime string `yaml:"conn_max_idle_time"`
+	ConnMaxLifetime string `yaml:"conn_max_lifetime"`
+}
+
+func (db *Database) Configure(cfg Config) error {
 	db.RawDB.SetMaxOpenConns(cfg.MaxOpenConns)
 	db.RawDB.SetMaxIdleConns(cfg.MaxIdleConns)
 	if len(cfg.ConnMaxIdleTime) > 0 {
@@ -196,7 +205,7 @@ func (db *Database) Configure(cfg bridgeconfig.DatabaseConfig) error {
 	return nil
 }

-func NewFromConfig(owner string, cfg bridgeconfig.DatabaseConfig, logger DatabaseLogger) (*Database, error) {
+func NewFromConfig(owner string, cfg Config, logger DatabaseLogger) (*Database, error) {
 	dialect, err := ParseDialect(cfg.Type)
 	if err != nil {
 		return nil, err
--- a/vendor/maunium.net/go/mautrix/util/dbutil/log.go
+++ b/vendor/maunium.net/go/mautrix/util/dbutil/log.go
@@ -11,9 +11,9 @@ import (
 )

 type DatabaseLogger interface {
-	QueryTiming(ctx context.Context, method, query string, args []interface{}, nrows int, duration time.Duration)
-	WarnUnsupportedVersion(current, latest int)
-	PrepareUpgrade(current, latest int)
+	QueryTiming(ctx context.Context, method, query string, args []interface{}, nrows int, duration time.Duration, err error)
+	WarnUnsupportedVersion(current, compat, latest int)
+	PrepareUpgrade(current, compat, latest int)
 	DoUpgrade(from, to int, message string, txn bool)
 	// Deprecated: legacy warning method, return errors instead
 	Warn(msg string, args ...interface{})
@@ -23,35 +23,36 @@ type noopLogger struct{}

 var NoopLogger DatabaseLogger = &noopLogger{}

-func (n noopLogger) WarnUnsupportedVersion(_, _ int)      {}
-func (n noopLogger) PrepareUpgrade(_, _ int)              {}
+func (n noopLogger) WarnUnsupportedVersion(_, _, _ int)   {}
+func (n noopLogger) PrepareUpgrade(_, _, _ int)           {}
 func (n noopLogger) DoUpgrade(_, _ int, _ string, _ bool) {}
 func (n noopLogger) Warn(msg string, args ...interface{}) {}

-func (n noopLogger) QueryTiming(_ context.Context, _, _ string, _ []interface{}, _ int, _ time.Duration) {
+func (n noopLogger) QueryTiming(_ context.Context, _, _ string, _ []interface{}, _ int, _ time.Duration, _ error) {
 }

 type mauLogger struct {
 	l maulogger.Logger
 }

+// Deprecated: Use zerolog instead
 func MauLogger(log maulogger.Logger) DatabaseLogger {
 	return &mauLogger{l: log}
 }

-func (m mauLogger) WarnUnsupportedVersion(current, latest int) {
-	m.l.Warnfln("Unsupported database schema version: currently on v%d, latest known: v%d - continuing anyway", current, latest)
+func (m mauLogger) WarnUnsupportedVersion(current, compat, latest int) {
+	m.l.Warnfln("Unsupported database schema version: currently on v%d (compatible down to v%d), latest known: v%d - continuing anyway", current, compat, latest)
 }

-func (m mauLogger) PrepareUpgrade(current, latest int) {
-	m.l.Infofln("Database currently on v%d, latest: v%d", current, latest)
+func (m mauLogger) PrepareUpgrade(current, compat, latest int) {
+	m.l.Infofln("Database currently on v%d (compat: v%d), latest known: v%d", current, compat, latest)
 }

 func (m mauLogger) DoUpgrade(from, to int, message string, _ bool) {
 	m.l.Infofln("Upgrading database from v%d to v%d: %s", from, to, message)
 }

-func (m mauLogger) QueryTiming(_ context.Context, method, query string, _ []interface{}, _ int, duration time.Duration) {
+func (m mauLogger) QueryTiming(_ context.Context, method, query string, _ []interface{}, _ int, duration time.Duration, _ error) {
 	if duration > 1*time.Second {
 		m.l.Warnfln("%s(%s) took %.3f seconds", method, query, duration.Seconds())
 	}
@@ -63,28 +64,40 @@ func (m mauLogger) Warn(msg string, args ...interface{}) {

 type zeroLogger struct {
 	l *zerolog.Logger
+	ZeroLogSettings
 }

-func ZeroLogger(log zerolog.Logger) DatabaseLogger {
-	return ZeroLoggerPtr(&log)
+type ZeroLogSettings struct {
+	CallerSkipFrame int
+	Caller          bool
 }

-func ZeroLoggerPtr(log *zerolog.Logger) DatabaseLogger {
-	return &zeroLogger{l: log}
+func ZeroLogger(log zerolog.Logger, cfg ...ZeroLogSettings) DatabaseLogger {
+	return ZeroLoggerPtr(&log, cfg...)
 }

-func (z zeroLogger) WarnUnsupportedVersion(current, latest int) {
+func ZeroLoggerPtr(log *zerolog.Logger, cfg ...ZeroLogSettings) DatabaseLogger {
+	wrapped := &zeroLogger{l: log}
+	if len(cfg) > 0 {
+		wrapped.ZeroLogSettings = cfg[0]
+	}
+	return wrapped
+}
+
+func (z zeroLogger) WarnUnsupportedVersion(current, compat, latest int) {
 	z.l.Warn().
-		Int("current_db_version", current).
+		Int("current_version", current).
+		Int("oldest_compatible_version", compat).
 		Int("latest_known_version", latest).
 		Msg("Unsupported database schema version, continuing anyway")
 }

-func (z zeroLogger) PrepareUpgrade(current, latest int) {
+func (z zeroLogger) PrepareUpgrade(current, compat, latest int) {
 	evt := z.l.Info().
-		Int("current_db_version", current).
+		Int("current_version", current).
+		Int("oldest_compatible_version", compat).
 		Int("latest_known_version", latest)
-	if current == latest {
+	if current >= latest {
 		evt.Msg("Database is up to date")
 	} else {
 		evt.Msg("Preparing to update database schema")
@@ -102,9 +115,9 @@ func (z zeroLogger) DoUpgrade(from, to int, message string, txn bool) {

 var whitespaceRegex = regexp.MustCompile(`\s+`)

-func (z zeroLogger) QueryTiming(ctx context.Context, method, query string, args []interface{}, nrows int, duration time.Duration) {
+func (z zeroLogger) QueryTiming(ctx context.Context, method, query string, args []interface{}, nrows int, duration time.Duration, err error) {
 	log := zerolog.Ctx(ctx)
-	if log.GetLevel() == zerolog.Disabled {
+	if log.GetLevel() == zerolog.Disabled || log == zerolog.DefaultContextLogger {
 		log = z.l
 	}
 	if log.GetLevel() != zerolog.TraceLevel && duration < 1*time.Second {
@@ -116,17 +129,21 @@ func (z zeroLogger) QueryTiming(ctx context.Context, method, query string, args
 	}
 	query = strings.TrimSpace(whitespaceRegex.ReplaceAllLiteralString(query, " "))
 	log.Trace().
+		Err(err).
 		Int64("duration_µs", duration.Microseconds()).
 		Str("method", method).
 		Str("query", query).
 		Interface("query_args", args).
 		Msg("Query")
 	if duration >= 1*time.Second {
-		log.Warn().
+		evt := log.Warn().
 			Float64("duration_seconds", duration.Seconds()).
 			Str("method", method).
-			Str("query", query).
-			Msg("Query took long")
+			Str("query", query)
+		if z.Caller {
+			evt = evt.Caller(z.CallerSkipFrame)
+		}
+		evt.Msg("Query took long")
 	}
 }

--- a/vendor/maunium.net/go/mautrix/util/dbutil/samples/05-compat.sql
+++ b/vendor/maunium.net/go/mautrix/util/dbutil/samples/05-compat.sql
@@ -0,0 +1,3 @@
+-- v5 (compatible with v3+): Sample backwards-compatible upgrade
+
+INSERT INTO foo VALUES ('meow 2', '{}');
--- a/vendor/maunium.net/go/mautrix/util/dbutil/samples/output/05-postgres.sql
+++ b/vendor/maunium.net/go/mautrix/util/dbutil/samples/output/05-postgres.sql
@@ -0,0 +1 @@
+INSERT INTO foo VALUES ('meow 2', '{}');
--- a/vendor/maunium.net/go/mautrix/util/dbutil/samples/output/05-sqlite3.sql
+++ b/vendor/maunium.net/go/mautrix/util/dbutil/samples/output/05-sqlite3.sql
@@ -0,0 +1 @@
+INSERT INTO foo VALUES ('meow 2', '{}');
--- a/vendor/maunium.net/go/mautrix/util/dbutil/transaction.go
+++ b/vendor/maunium.net/go/mautrix/util/dbutil/transaction.go
@@ -0,0 +1,82 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package dbutil
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/rs/zerolog"
+
+	"maunium.net/go/mautrix/util"
+)
+
+var (
+	ErrTxn       = errors.New("transaction")
+	ErrTxnBegin  = fmt.Errorf("%w: begin", ErrTxn)
+	ErrTxnCommit = fmt.Errorf("%w: commit", ErrTxn)
+)
+
+type contextKey int
+
+const (
+	ContextKeyDatabaseTransaction contextKey = iota
+	ContextKeyDoTxnCallerSkip
+)
+
+func (db *Database) DoTxn(ctx context.Context, opts *sql.TxOptions, fn func(ctx context.Context) error) error {
+	if ctx.Value(ContextKeyDatabaseTransaction) != nil {
+		zerolog.Ctx(ctx).Debug().Msg("Already in a transaction, not creating a new one")
+		return fn(ctx)
+	}
+	log := zerolog.Ctx(ctx).With().Str("db_txn_id", util.RandomString(12)).Logger()
+	start := time.Now()
+	defer func() {
+		dur := time.Since(start)
+		if dur > time.Second {
+			val := ctx.Value(ContextKeyDoTxnCallerSkip)
+			callerSkip := 2
+			if val != nil {
+				callerSkip += val.(int)
+			}
+			log.Warn().
+				Float64("duration_seconds", dur.Seconds()).
+				Caller(callerSkip).
+				Msg("Transaction took a long time")
+		}
+	}()
+	tx, err := db.BeginTx(ctx, opts)
+	if err != nil {
+		log.Trace().Err(err).Msg("Failed to begin transaction")
+		return util.NewDualError(ErrTxnBegin, err)
+	}
+	log.Trace().Msg("Transaction started")
+	tx.noTotalLog = true
+	ctx = log.WithContext(ctx)
+	ctx = context.WithValue(ctx, ContextKeyDatabaseTransaction, tx)
+	err = fn(ctx)
+	if err != nil {
+		log.Trace().Err(err).Msg("Database transaction failed, rolling back")
+		rollbackErr := tx.Rollback()
+		if rollbackErr != nil {
+			log.Warn().Err(rollbackErr).Msg("Rollback after transaction error failed")
+		} else {
+			log.Trace().Msg("Rollback successful")
+		}
+		return err
+	}
+	err = tx.Commit()
+	if err != nil {
+		log.Trace().Err(err).Msg("Commit failed")
+		return util.NewDualError(ErrTxnCommit, err)
+	}
+	log.Trace().Msg("Commit successful")
+	return nil
+}
--- a/vendor/maunium.net/go/mautrix/util/dbutil/upgrades.go
+++ b/vendor/maunium.net/go/mautrix/util/dbutil/upgrades.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Tulir Asokan
+// Copyright (c) 2023 Tulir Asokan
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -18,42 +18,97 @@ type upgrade struct {
 	message string
 	fn      upgradeFunc

-	upgradesTo  int
-	transaction bool
+	upgradesTo    int
+	compatVersion int
+	transaction   bool
 }

-var ErrUnsupportedDatabaseVersion = fmt.Errorf("unsupported database schema version")
-var ErrForeignTables = fmt.Errorf("the database contains foreign tables")
-var ErrNotOwned = fmt.Errorf("the database is owned by")
+var ErrUnsupportedDatabaseVersion = errors.New("unsupported database schema version")
+var ErrForeignTables = errors.New("the database contains foreign tables")
+var ErrNotOwned = errors.New("the database is owned by")
+var ErrUnsupportedDialect = errors.New("unsupported database dialect")

-func (db *Database) getVersion() (int, error) {
-	_, err := db.Exec(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (version INTEGER)", db.VersionTable))
-	if err != nil {
-		return -1, err
+func (db *Database) upgradeVersionTable() error {
+	if compatColumnExists, err := db.ColumnExists(nil, db.VersionTable, "compat"); err != nil {
+		return fmt.Errorf("failed to check if version table is up to date: %w", err)
+	} else if !compatColumnExists {
+		if tableExists, err := db.TableExists(nil, db.VersionTable); err != nil {
+			return fmt.Errorf("failed to check if version table exists: %w", err)
+		} else if !tableExists {
+			_, err = db.Exec(fmt.Sprintf("CREATE TABLE %s (version INTEGER, compat INTEGER)", db.VersionTable))
+			if err != nil {
+				return fmt.Errorf("failed to create version table: %w", err)
+			}
+		} else {
+			_, err = db.Exec(fmt.Sprintf("ALTER TABLE %s ADD COLUMN compat INTEGER", db.VersionTable))
+			if err != nil {
+				return fmt.Errorf("failed to add compat column to version table: %w", err)
+			}
+		}
 	}
-
-	version := 0
-	err = db.QueryRow(fmt.Sprintf("SELECT version FROM %s LIMIT 1", db.VersionTable)).Scan(&version)
-	if err != nil && !errors.Is(err, sql.ErrNoRows) {
-		return -1, err
-	}
-	return version, nil
+	return nil
 }

-const tableExistsPostgres = "SELECT EXISTS(SELECT 1 FROM information_schema.tables WHERE table_name=$1)"
-const tableExistsSQLite = "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND tbl_name=$1)"
+func (db *Database) getVersion() (version, compat int, err error) {
+	if err = db.upgradeVersionTable(); err != nil {
+		return
+	}

-func (db *Database) tableExists(table string) (exists bool, err error) {
-	if db.Dialect == SQLite {
+	var compatNull sql.NullInt32
+	err = db.QueryRow(fmt.Sprintf("SELECT version, compat FROM %s LIMIT 1", db.VersionTable)).Scan(&version, &compatNull)
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if compatNull.Valid && compatNull.Int32 != 0 {
+		compat = int(compatNull.Int32)
+	} else {
+		compat = version
+	}
+	return
+}
+
+const (
+	tableExistsPostgres = "SELECT EXISTS(SELECT 1 FROM information_schema.tables WHERE table_name=$1)"
+	tableExistsSQLite   = "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND tbl_name=?1)"
+)
+
+func (db *Database) TableExists(tx Execable, table string) (exists bool, err error) {
+	if tx == nil {
+		tx = db
+	}
+	switch db.Dialect {
+	case SQLite:
 		err = db.QueryRow(tableExistsSQLite, table).Scan(&exists)
-	} else if db.Dialect == Postgres {
+	case Postgres:
 		err = db.QueryRow(tableExistsPostgres, table).Scan(&exists)
+	default:
+		err = ErrUnsupportedDialect
+	}
+	return
+}
+
+const (
+	columnExistsPostgres = "SELECT EXISTS(SELECT 1 FROM information_schema.columns WHERE table_name=$1 AND column_name=$2)"
+	columnExistsSQLite   = "SELECT EXISTS(SELECT 1 FROM pragma_table_info(?1) WHERE name=?2)"
+)
+
+func (db *Database) ColumnExists(tx Execable, table, column string) (exists bool, err error) {
+	if tx == nil {
+		tx = db
+	}
+	switch db.Dialect {
+	case SQLite:
+		err = db.QueryRow(columnExistsSQLite, table, column).Scan(&exists)
+	case Postgres:
+		err = db.QueryRow(columnExistsPostgres, table, column).Scan(&exists)
+	default:
+		err = ErrUnsupportedDialect
 	}
 	return
 }

 func (db *Database) tableExistsNoError(table string) bool {
-	exists, err := db.tableExists(table)
+	exists, err := db.TableExists(nil, table)
 	if err != nil {
 		panic(fmt.Errorf("failed to check if table exists: %w", err))
 	}
@@ -94,12 +149,12 @@ func (db *Database) checkDatabaseOwner() error {
 	return nil
 }

-func (db *Database) setVersion(tx Execable, version int) error {
+func (db *Database) setVersion(tx Execable, version, compat int) error {
 	_, err := tx.Exec(fmt.Sprintf("DELETE FROM %s", db.VersionTable))
 	if err != nil {
 		return err
 	}
-	_, err = tx.Exec(fmt.Sprintf("INSERT INTO %s (version) VALUES ($1)", db.VersionTable), version)
+	_, err = tx.Exec(fmt.Sprintf("INSERT INTO %s (version, compat) VALUES ($1, $2)", db.VersionTable), version, compat)
 	return err
 }

@@ -109,20 +164,20 @@ func (db *Database) Upgrade() error {
 		return err
 	}

-	version, err := db.getVersion()
+	version, compat, err := db.getVersion()
 	if err != nil {
 		return err
 	}

-	if version > len(db.UpgradeTable) {
+	if compat > len(db.UpgradeTable) {
 		if db.IgnoreUnsupportedDatabase {
-			db.Log.WarnUnsupportedVersion(version, len(db.UpgradeTable))
+			db.Log.WarnUnsupportedVersion(version, compat, len(db.UpgradeTable))
 			return nil
 		}
-		return fmt.Errorf("%w: currently on v%d, latest known: v%d", ErrUnsupportedDatabaseVersion, version, len(db.UpgradeTable))
+		return fmt.Errorf("%w: currently on v%d (compatible down to v%d), latest known: v%d", ErrUnsupportedDatabaseVersion, version, compat, len(db.UpgradeTable))
 	}

-	db.Log.PrepareUpgrade(version, len(db.UpgradeTable))
+	db.Log.PrepareUpgrade(version, compat, len(db.UpgradeTable))
 	logVersion := version
 	for version < len(db.UpgradeTable) {
 		upgradeItem := db.UpgradeTable[version]
@@ -148,7 +203,7 @@ func (db *Database) Upgrade() error {
 		}
 		version = upgradeItem.upgradesTo
 		logVersion = version
-		err = db.setVersion(upgradeConn, version)
+		err = db.setVersion(upgradeConn, version, upgradeItem.compatVersion)
 		if err != nil {
 			return err
 		}
--- a/vendor/maunium.net/go/mautrix/util/dbutil/upgradetable.go
+++ b/vendor/maunium.net/go/mautrix/util/dbutil/upgradetable.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2022 Tulir Asokan
+// Copyright (c) 2023 Tulir Asokan
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -29,14 +29,17 @@ func (ut *UpgradeTable) extend(toSize int) {
 	}
 }

-func (ut *UpgradeTable) Register(from, to int, message string, txn bool, fn upgradeFunc) {
+func (ut *UpgradeTable) Register(from, to, compat int, message string, txn bool, fn upgradeFunc) {
 	if from < 0 {
 		from += to
 	}
 	if from < 0 {
 		panic("invalid from value in UpgradeTable.Register() call")
 	}
-	upg := upgrade{message: message, fn: fn, upgradesTo: to, transaction: txn}
+	if compat <= 0 {
+		compat = to
+	}
+	upg := upgrade{message: message, fn: fn, upgradesTo: to, compatVersion: compat, transaction: txn}
 	if len(*ut) == from {
 		*ut = append(*ut, upg)
 		return
@@ -55,7 +58,11 @@ func (ut *UpgradeTable) Register(from, to int, message string, txn bool, fn upgr
 // or
 //
 //	-- v1: Message
-var upgradeHeaderRegex = regexp.MustCompile(`^-- (?:v(\d+) -> )?v(\d+): (.+)$`)
+//
+// Both syntaxes may also have a compatibility notice before the colon:
+//
+//	-- v5 (compatible with v3+): Upgrade with backwards compatibility
+var upgradeHeaderRegex = regexp.MustCompile(`^-- (?:v(\d+) -> )?v(\d+)(?: \(compatible with v(\d+)\+\))?: (.+)$`)

 // To disable wrapping the upgrade in a single transaction, put `--transaction: off` on the second line.
 //
@@ -64,7 +71,7 @@ var upgradeHeaderRegex = regexp.MustCompile(`^-- (?:v(\d+) -> )?v(\d+): (.+)$`)
 //	// do dangerous stuff
 var transactionDisableRegex = regexp.MustCompile(`^-- transaction: (\w*)`)

-func parseFileHeader(file []byte) (from, to int, message string, txn bool, lines [][]byte, err error) {
+func parseFileHeader(file []byte) (from, to, compat int, message string, txn bool, lines [][]byte, err error) {
 	lines = bytes.Split(file, []byte("\n"))
 	if len(lines) < 2 {
 		err = errors.New("upgrade file too short")
@@ -75,19 +82,22 @@ func parseFileHeader(file []byte) (from, to int, message string, txn bool, lines
 	lines = lines[1:]
 	if match == nil {
 		err = errors.New("header not found")
-	} else if len(match) != 4 {
+	} else if len(match) != 5 {
 		err = errors.New("unexpected number of items in regex match")
 	} else if maybeFrom, err = strconv.Atoi(string(match[1])); len(match[1]) > 0 && err != nil {
 		err = fmt.Errorf("invalid source version: %w", err)
 	} else if to, err = strconv.Atoi(string(match[2])); err != nil {
 		err = fmt.Errorf("invalid target version: %w", err)
+	} else if compat, err = strconv.Atoi(string(match[3])); len(match[3]) > 0 && err != nil {
+		err = fmt.Errorf("invalid compatible version: %w", err)
 	} else {
+		err = nil
 		if len(match[1]) > 0 {
 			from = maybeFrom
 		} else {
 			from = -1
 		}
-		message = string(match[3])
+		message = string(match[4])
 		txn = true
 		match = transactionDisableRegex.FindSubmatch(lines[0])
 		if match != nil {
@@ -205,7 +215,7 @@ func splitSQLUpgradeFunc(sqliteData, postgresData string) upgradeFunc {
 	}
 }

-func parseSplitSQLUpgrade(name string, fs fullFS, skipNames map[string]struct{}) (from, to int, message string, txn bool, fn upgradeFunc) {
+func parseSplitSQLUpgrade(name string, fs fullFS, skipNames map[string]struct{}) (from, to, compat int, message string, txn bool, fn upgradeFunc) {
 	postgresName := fmt.Sprintf("%s.postgres.sql", name)
 	sqliteName := fmt.Sprintf("%s.sqlite.sql", name)
 	skipNames[postgresName] = struct{}{}
@@ -218,15 +228,15 @@ func parseSplitSQLUpgrade(name string, fs fullFS, skipNames map[string]struct{})
 	if err != nil {
 		panic(err)
 	}
-	from, to, message, txn, _, err = parseFileHeader(postgresData)
+	from, to, compat, message, txn, _, err = parseFileHeader(postgresData)
 	if err != nil {
 		panic(fmt.Errorf("failed to parse header in %s: %w", postgresName, err))
 	}
-	sqliteFrom, sqliteTo, sqliteMessage, sqliteTxn, _, err := parseFileHeader(sqliteData)
+	sqliteFrom, sqliteTo, sqliteCompat, sqliteMessage, sqliteTxn, _, err := parseFileHeader(sqliteData)
 	if err != nil {
 		panic(fmt.Errorf("failed to parse header in %s: %w", sqliteName, err))
 	}
-	if from != sqliteFrom || to != sqliteTo {
+	if from != sqliteFrom || to != sqliteTo || compat != sqliteCompat {
 		panic(fmt.Errorf("mismatching versions in postgres and sqlite versions of %s: %d/%d -> %d/%d", name, from, sqliteFrom, to, sqliteTo))
 	} else if message != sqliteMessage {
 		panic(fmt.Errorf("mismatching message in postgres and sqlite versions of %s: %q != %q", name, message, sqliteMessage))
@@ -260,14 +270,14 @@ func (ut *UpgradeTable) RegisterFSPath(fs fullFS, dir string) {
 		} else if _, skip := skipNames[file.Name()]; skip {
 			// also do nothing
 		} else if splitName := splitFileNameRegex.FindStringSubmatch(file.Name()); splitName != nil {
-			from, to, message, txn, fn := parseSplitSQLUpgrade(splitName[1], fs, skipNames)
-			ut.Register(from, to, message, txn, fn)
+			from, to, compat, message, txn, fn := parseSplitSQLUpgrade(splitName[1], fs, skipNames)
+			ut.Register(from, to, compat, message, txn, fn)
 		} else if data, err := fs.ReadFile(filepath.Join(dir, file.Name())); err != nil {
 			panic(err)
-		} else if from, to, message, txn, lines, err := parseFileHeader(data); err != nil {
+		} else if from, to, compat, message, txn, lines, err := parseFileHeader(data); err != nil {
 			panic(fmt.Errorf("failed to parse header in %s: %w", file.Name(), err))
 		} else {
-			ut.Register(from, to, message, txn, sqlUpgradeFunc(file.Name(), lines))
+			ut.Register(from, to, compat, message, txn, sqlUpgradeFunc(file.Name(), lines))
 		}
 	}
 }