ntfy/server/message_cache.go

668 lines
19 KiB
Go
Raw Normal View History

2021-11-02 19:08:21 +01:00
package server
import (
2022-02-27 20:21:34 +01:00
"database/sql"
2022-04-19 15:14:32 +02:00
"encoding/json"
2021-12-07 17:45:15 +01:00
"errors"
2022-02-27 20:21:34 +01:00
"fmt"
2021-11-02 19:08:21 +01:00
_ "github.com/mattn/go-sqlite3" // SQLite driver
"heckel.io/ntfy/log"
2022-02-27 20:21:34 +01:00
"heckel.io/ntfy/util"
"strings"
2021-11-03 02:09:49 +01:00
"time"
2021-11-02 19:08:21 +01:00
)
2021-12-07 17:45:15 +01:00
var (
errUnexpectedMessageType = errors.New("unexpected message type")
)
2022-02-27 20:21:34 +01:00
// Messages cache
const (
createMessagesTableQuery = `
BEGIN;
CREATE TABLE IF NOT EXISTS messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
mid TEXT NOT NULL,
time INT NOT NULL,
topic TEXT NOT NULL,
message TEXT NOT NULL,
title TEXT NOT NULL,
priority INT NOT NULL,
tags TEXT NOT NULL,
click TEXT NOT NULL,
2022-04-19 15:14:32 +02:00
actions TEXT NOT NULL,
2022-02-27 20:21:34 +01:00
attachment_name TEXT NOT NULL,
attachment_type TEXT NOT NULL,
attachment_size INT NOT NULL,
attachment_expires INT NOT NULL,
attachment_url TEXT NOT NULL,
sender TEXT NOT NULL,
2022-02-27 20:21:34 +01:00
encoding TEXT NOT NULL,
2022-07-16 21:31:03 +02:00
published INT NOT NULL,
icon_url TEXT NOT NULL,
icon_type TEXT NOT NULL,
icon_size INT NOT NULL
2022-02-27 20:21:34 +01:00
);
CREATE INDEX IF NOT EXISTS idx_mid ON messages (mid);
CREATE INDEX IF NOT EXISTS idx_topic ON messages (topic);
COMMIT;
`
insertMessageQuery = `
2022-07-16 21:31:03 +02:00
INSERT INTO messages (mid, time, topic, message, title, priority, tags, click, actions, attachment_name, attachment_type, attachment_size, attachment_expires, attachment_url, sender, encoding, published, icon_url, icon_type, icon_size)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
2022-02-27 20:21:34 +01:00
`
pruneMessagesQuery = `DELETE FROM messages WHERE time < ? AND published = 1`
selectRowIDFromMessageID = `SELECT id FROM messages WHERE mid = ?` // Do not include topic, see #336 and TestServer_PollSinceID_MultipleTopics
2022-02-27 20:21:34 +01:00
selectMessagesSinceTimeQuery = `
2022-07-16 21:31:03 +02:00
SELECT mid, time, topic, message, title, priority, tags, click, actions, attachment_name, attachment_type, attachment_size, attachment_expires, attachment_url, sender, encoding, icon_url, icon_type, icon_size
2022-02-27 20:21:34 +01:00
FROM messages
WHERE topic = ? AND time >= ? AND published = 1
ORDER BY time, id
`
selectMessagesSinceTimeIncludeScheduledQuery = `
2022-07-16 21:31:03 +02:00
SELECT mid, time, topic, message, title, priority, tags, click, actions, attachment_name, attachment_type, attachment_size, attachment_expires, attachment_url, sender, encoding, icon_url, icon_type, icon_size
2022-02-27 20:21:34 +01:00
FROM messages
WHERE topic = ? AND time >= ?
ORDER BY time, id
`
selectMessagesSinceIDQuery = `
2022-07-16 21:31:03 +02:00
SELECT mid, time, topic, message, title, priority, tags, click, actions, attachment_name, attachment_type, attachment_size, attachment_expires, attachment_url, sender, encoding, icon_url, icon_type, icon_size
2022-02-27 20:21:34 +01:00
FROM messages
WHERE topic = ? AND id > ? AND published = 1
ORDER BY time, id
`
selectMessagesSinceIDIncludeScheduledQuery = `
2022-07-16 21:31:03 +02:00
SELECT mid, time, topic, message, title, priority, tags, click, actions, attachment_name, attachment_type, attachment_size, attachment_expires, attachment_url, sender, encoding, icon_url, icon_type, icon_size
2022-02-27 20:21:34 +01:00
FROM messages
WHERE topic = ? AND (id > ? OR published = 0)
ORDER BY time, id
`
selectMessagesDueQuery = `
2022-07-16 21:31:03 +02:00
SELECT mid, time, topic, message, title, priority, tags, click, actions, attachment_name, attachment_type, attachment_size, attachment_expires, attachment_url, sender, encoding, icon_url, icon_type, icon_size
2022-02-27 20:21:34 +01:00
FROM messages
WHERE time <= ? AND published = 0
ORDER BY time, id
`
updateMessagePublishedQuery = `UPDATE messages SET published = 1 WHERE mid = ?`
selectMessagesCountQuery = `SELECT COUNT(*) FROM messages`
2022-06-22 01:07:27 +02:00
selectMessageCountPerTopicQuery = `SELECT topic, COUNT(*) FROM messages GROUP BY topic`
2022-02-27 20:21:34 +01:00
selectTopicsQuery = `SELECT topic FROM messages GROUP BY topic`
selectAttachmentsSizeQuery = `SELECT IFNULL(SUM(attachment_size), 0) FROM messages WHERE sender = ? AND attachment_expires >= ?`
2022-02-27 20:21:34 +01:00
)
// Schema management queries
const (
2022-07-16 21:31:03 +02:00
currentSchemaVersion = 8
2022-02-27 20:21:34 +01:00
createSchemaVersionTableQuery = `
CREATE TABLE IF NOT EXISTS schemaVersion (
id INT PRIMARY KEY,
version INT NOT NULL
);
`
insertSchemaVersion = `INSERT INTO schemaVersion VALUES (1, ?)`
updateSchemaVersion = `UPDATE schemaVersion SET version = ? WHERE id = 1`
selectSchemaVersionQuery = `SELECT version FROM schemaVersion WHERE id = 1`
// 0 -> 1
migrate0To1AlterMessagesTableQuery = `
BEGIN;
ALTER TABLE messages ADD COLUMN title TEXT NOT NULL DEFAULT('');
ALTER TABLE messages ADD COLUMN priority INT NOT NULL DEFAULT(0);
ALTER TABLE messages ADD COLUMN tags TEXT NOT NULL DEFAULT('');
COMMIT;
`
// 1 -> 2
migrate1To2AlterMessagesTableQuery = `
ALTER TABLE messages ADD COLUMN published INT NOT NULL DEFAULT(1);
`
// 2 -> 3
migrate2To3AlterMessagesTableQuery = `
BEGIN;
ALTER TABLE messages ADD COLUMN click TEXT NOT NULL DEFAULT('');
ALTER TABLE messages ADD COLUMN attachment_name TEXT NOT NULL DEFAULT('');
ALTER TABLE messages ADD COLUMN attachment_type TEXT NOT NULL DEFAULT('');
ALTER TABLE messages ADD COLUMN attachment_size INT NOT NULL DEFAULT('0');
ALTER TABLE messages ADD COLUMN attachment_expires INT NOT NULL DEFAULT('0');
ALTER TABLE messages ADD COLUMN attachment_owner TEXT NOT NULL DEFAULT('');
ALTER TABLE messages ADD COLUMN attachment_url TEXT NOT NULL DEFAULT('');
COMMIT;
`
// 3 -> 4
migrate3To4AlterMessagesTableQuery = `
ALTER TABLE messages ADD COLUMN encoding TEXT NOT NULL DEFAULT('');
`
// 4 -> 5
migrate4To5AlterMessagesTableQuery = `
BEGIN;
CREATE TABLE IF NOT EXISTS messages_new (
id INTEGER PRIMARY KEY AUTOINCREMENT,
mid TEXT NOT NULL,
time INT NOT NULL,
topic TEXT NOT NULL,
message TEXT NOT NULL,
title TEXT NOT NULL,
priority INT NOT NULL,
tags TEXT NOT NULL,
click TEXT NOT NULL,
attachment_name TEXT NOT NULL,
attachment_type TEXT NOT NULL,
attachment_size INT NOT NULL,
attachment_expires INT NOT NULL,
attachment_url TEXT NOT NULL,
attachment_owner TEXT NOT NULL,
encoding TEXT NOT NULL,
published INT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_mid ON messages_new (mid);
CREATE INDEX IF NOT EXISTS idx_topic ON messages_new (topic);
INSERT
INTO messages_new (
mid, time, topic, message, title, priority, tags, click, attachment_name, attachment_type,
attachment_size, attachment_expires, attachment_url, attachment_owner, encoding, published)
SELECT
id, time, topic, message, title, priority, tags, click, attachment_name, attachment_type,
attachment_size, attachment_expires, attachment_url, attachment_owner, encoding, published
FROM messages;
DROP TABLE messages;
ALTER TABLE messages_new RENAME TO messages;
COMMIT;
`
2022-04-21 15:58:28 +02:00
// 5 -> 6
migrate5To6AlterMessagesTableQuery = `
ALTER TABLE messages ADD COLUMN actions TEXT NOT NULL DEFAULT('');
`
// 6 -> 7
migrate6To7AlterMessagesTableQuery = `
ALTER TABLE messages RENAME COLUMN attachment_owner TO sender;
`
2022-07-16 21:31:03 +02:00
// 7 -> 8
migrate7To8AlterMessagesTableQuery = `
ALTER TABLE messages ADD COLUMN icon_url TEXT NOT NULL DEFAULT('');
ALTER TABLE messages ADD COLUMN icon_type TEXT NOT NULL DEFAULT('');
ALTER TABLE messages ADD COLUMN icon_size INT NOT NULL DEFAULT('0');
`
2022-02-27 20:21:34 +01:00
)
2022-02-27 20:47:28 +01:00
type messageCache struct {
2022-02-27 20:21:34 +01:00
db *sql.DB
nop bool
}
2022-02-27 20:47:28 +01:00
// newSqliteCache creates a SQLite file-backed cache
2022-06-23 17:02:45 +02:00
func newSqliteCache(filename, startupQueries string, nop bool) (*messageCache, error) {
2022-02-27 20:21:34 +01:00
db, err := sql.Open("sqlite3", filename)
if err != nil {
return nil, err
}
2022-06-23 17:02:45 +02:00
if err := setupCacheDB(db, startupQueries); err != nil {
2022-02-27 20:21:34 +01:00
return nil, err
}
2022-02-27 20:47:28 +01:00
return &messageCache{
2022-02-27 20:21:34 +01:00
db: db,
nop: nop,
}, nil
}
// newMemCache creates an in-memory cache
2022-02-27 20:47:28 +01:00
func newMemCache() (*messageCache, error) {
2022-06-23 17:02:45 +02:00
return newSqliteCache(createMemoryFilename(), "", false)
2022-02-27 20:21:34 +01:00
}
// newNopCache creates an in-memory cache that discards all messages;
// it is always empty and can be used if caching is entirely disabled
2022-02-27 20:47:28 +01:00
func newNopCache() (*messageCache, error) {
2022-06-23 17:02:45 +02:00
return newSqliteCache(createMemoryFilename(), "", true)
2022-02-27 20:21:34 +01:00
}
// createMemoryFilename creates a unique memory filename to use for the SQLite backend.
// From mattn/go-sqlite3: "Each connection to ":memory:" opens a brand new in-memory
// sql database, so if the stdlib's sql engine happens to open another connection and
// you've only specified ":memory:", that connection will see a brand new database.
// A workaround is to use "file::memory:?cache=shared" (or "file:foobar?mode=memory&cache=shared").
// Every connection to this string will point to the same in-memory database."
func createMemoryFilename() string {
return fmt.Sprintf("file:%s?mode=memory&cache=shared", util.RandomString(10))
}
2022-02-27 20:47:28 +01:00
func (c *messageCache) AddMessage(m *message) error {
2022-06-23 02:17:47 +02:00
return c.addMessages([]*message{m})
}
func (c *messageCache) addMessages(ms []*message) error {
2022-02-27 20:21:34 +01:00
if c.nop {
return nil
}
2022-06-23 02:17:47 +02:00
tx, err := c.db.Begin()
if err != nil {
return err
2022-02-27 20:21:34 +01:00
}
2022-06-23 02:17:47 +02:00
defer tx.Rollback()
for _, m := range ms {
if m.Event != messageEvent {
return errUnexpectedMessageType
}
published := m.Time <= time.Now().Unix()
tags := strings.Join(m.Tags, ",")
var attachmentName, attachmentType, attachmentURL string
var attachmentSize, attachmentExpires int64
if m.Attachment != nil {
attachmentName = m.Attachment.Name
attachmentType = m.Attachment.Type
attachmentSize = m.Attachment.Size
attachmentExpires = m.Attachment.Expires
attachmentURL = m.Attachment.URL
}
2022-07-16 21:31:03 +02:00
var iconURL, iconType string
var iconSize int64
if m.Icon != nil {
iconURL = m.Icon.URL
iconType = m.Icon.Type
iconSize = m.Icon.Size
}
2022-06-23 02:17:47 +02:00
var actionsStr string
if len(m.Actions) > 0 {
actionsBytes, err := json.Marshal(m.Actions)
if err != nil {
return err
}
actionsStr = string(actionsBytes)
}
_, err := tx.Exec(
insertMessageQuery,
m.ID,
m.Time,
m.Topic,
m.Message,
m.Title,
m.Priority,
tags,
m.Click,
actionsStr,
attachmentName,
attachmentType,
attachmentSize,
attachmentExpires,
attachmentURL,
m.Sender,
m.Encoding,
published,
2022-07-16 21:31:03 +02:00
iconURL,
iconType,
iconSize,
2022-06-23 02:17:47 +02:00
)
2022-04-19 15:14:32 +02:00
if err != nil {
return err
}
}
2022-06-23 02:17:47 +02:00
return tx.Commit()
2022-02-27 20:21:34 +01:00
}
2022-02-27 20:47:28 +01:00
func (c *messageCache) Messages(topic string, since sinceMarker, scheduled bool) ([]*message, error) {
2022-02-27 20:21:34 +01:00
if since.IsNone() {
return make([]*message, 0), nil
} else if since.IsID() {
return c.messagesSinceID(topic, since, scheduled)
}
return c.messagesSinceTime(topic, since, scheduled)
}
2022-02-27 20:47:28 +01:00
func (c *messageCache) messagesSinceTime(topic string, since sinceMarker, scheduled bool) ([]*message, error) {
2022-02-27 20:21:34 +01:00
var rows *sql.Rows
var err error
if scheduled {
rows, err = c.db.Query(selectMessagesSinceTimeIncludeScheduledQuery, topic, since.Time().Unix())
} else {
rows, err = c.db.Query(selectMessagesSinceTimeQuery, topic, since.Time().Unix())
}
if err != nil {
return nil, err
}
return readMessages(rows)
}
2022-02-27 20:47:28 +01:00
func (c *messageCache) messagesSinceID(topic string, since sinceMarker, scheduled bool) ([]*message, error) {
idrows, err := c.db.Query(selectRowIDFromMessageID, since.ID())
2022-02-27 20:21:34 +01:00
if err != nil {
return nil, err
}
defer idrows.Close()
if !idrows.Next() {
return c.messagesSinceTime(topic, sinceAllMessages, scheduled)
}
var rowID int64
if err := idrows.Scan(&rowID); err != nil {
return nil, err
}
idrows.Close()
var rows *sql.Rows
if scheduled {
rows, err = c.db.Query(selectMessagesSinceIDIncludeScheduledQuery, topic, rowID)
} else {
rows, err = c.db.Query(selectMessagesSinceIDQuery, topic, rowID)
}
if err != nil {
return nil, err
}
return readMessages(rows)
}
2022-02-27 20:47:28 +01:00
func (c *messageCache) MessagesDue() ([]*message, error) {
2022-02-27 20:21:34 +01:00
rows, err := c.db.Query(selectMessagesDueQuery, time.Now().Unix())
if err != nil {
return nil, err
}
return readMessages(rows)
}
2022-02-27 20:47:28 +01:00
func (c *messageCache) MarkPublished(m *message) error {
2022-02-27 20:21:34 +01:00
_, err := c.db.Exec(updateMessagePublishedQuery, m.ID)
return err
}
2022-06-22 01:07:27 +02:00
func (c *messageCache) MessageCounts() (map[string]int, error) {
rows, err := c.db.Query(selectMessageCountPerTopicQuery)
2022-02-27 20:21:34 +01:00
if err != nil {
2022-06-22 01:07:27 +02:00
return nil, err
2022-02-27 20:21:34 +01:00
}
defer rows.Close()
2022-06-22 01:07:27 +02:00
var topic string
2022-02-27 20:21:34 +01:00
var count int
2022-06-22 01:07:27 +02:00
counts := make(map[string]int)
for rows.Next() {
if err := rows.Scan(&topic, &count); err != nil {
return nil, err
} else if err := rows.Err(); err != nil {
return nil, err
}
counts[topic] = count
2022-02-27 20:21:34 +01:00
}
2022-06-22 01:07:27 +02:00
return counts, nil
2022-02-27 20:21:34 +01:00
}
2022-02-27 20:47:28 +01:00
func (c *messageCache) Topics() (map[string]*topic, error) {
2022-02-27 20:21:34 +01:00
rows, err := c.db.Query(selectTopicsQuery)
if err != nil {
return nil, err
}
defer rows.Close()
topics := make(map[string]*topic)
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
topics[id] = newTopic(id)
}
if err := rows.Err(); err != nil {
return nil, err
}
return topics, nil
}
2022-02-27 20:47:28 +01:00
func (c *messageCache) Prune(olderThan time.Time) error {
2022-02-27 20:21:34 +01:00
_, err := c.db.Exec(pruneMessagesQuery, olderThan.Unix())
return err
}
func (c *messageCache) AttachmentBytesUsed(sender string) (int64, error) {
rows, err := c.db.Query(selectAttachmentsSizeQuery, sender, time.Now().Unix())
2022-02-27 20:21:34 +01:00
if err != nil {
return 0, err
}
defer rows.Close()
var size int64
if !rows.Next() {
return 0, errors.New("no rows found")
}
if err := rows.Scan(&size); err != nil {
return 0, err
} else if err := rows.Err(); err != nil {
return 0, err
}
return size, nil
}
func readMessages(rows *sql.Rows) ([]*message, error) {
defer rows.Close()
messages := make([]*message, 0)
for rows.Next() {
2022-07-16 21:31:03 +02:00
var timestamp, attachmentSize, attachmentExpires, iconSize int64
2022-02-27 20:21:34 +01:00
var priority int
2022-07-16 21:31:03 +02:00
var id, topic, msg, title, tagsStr, click, actionsStr, attachmentName, attachmentType, attachmentURL, sender, encoding, iconURL, iconType string
2022-02-27 20:21:34 +01:00
err := rows.Scan(
&id,
&timestamp,
&topic,
&msg,
&title,
&priority,
&tagsStr,
&click,
2022-04-19 15:14:32 +02:00
&actionsStr,
2022-02-27 20:21:34 +01:00
&attachmentName,
&attachmentType,
&attachmentSize,
&attachmentExpires,
&attachmentURL,
&sender,
2022-02-27 20:21:34 +01:00
&encoding,
2022-07-16 21:31:03 +02:00
&iconURL,
&iconType,
&iconSize,
2022-02-27 20:21:34 +01:00
)
if err != nil {
return nil, err
}
var tags []string
if tagsStr != "" {
tags = strings.Split(tagsStr, ",")
}
2022-04-19 15:14:32 +02:00
var actions []*action
if actionsStr != "" {
if err := json.Unmarshal([]byte(actionsStr), &actions); err != nil {
return nil, err
}
}
2022-02-27 20:21:34 +01:00
var att *attachment
if attachmentName != "" && attachmentURL != "" {
att = &attachment{
Name: attachmentName,
Type: attachmentType,
Size: attachmentSize,
Expires: attachmentExpires,
URL: attachmentURL,
}
}
2022-07-16 21:31:03 +02:00
var ico *icon
if iconURL != "" {
ico = &icon{
URL: iconURL,
Type: iconType,
Size: iconSize,
}
}
2022-02-27 20:21:34 +01:00
messages = append(messages, &message{
ID: id,
Time: timestamp,
Event: messageEvent,
Topic: topic,
Message: msg,
Title: title,
Priority: priority,
Tags: tags,
Click: click,
2022-07-16 21:31:03 +02:00
Icon: ico,
2022-04-19 15:14:32 +02:00
Actions: actions,
2022-02-27 20:21:34 +01:00
Attachment: att,
Sender: sender,
2022-02-27 20:21:34 +01:00
Encoding: encoding,
})
}
if err := rows.Err(); err != nil {
return nil, err
}
return messages, nil
}
2022-06-23 17:02:45 +02:00
func setupCacheDB(db *sql.DB, startupQueries string) error {
// Run startup queries
if startupQueries != "" {
if _, err := db.Exec(startupQueries); err != nil {
return err
}
2022-06-23 02:17:47 +02:00
}
2022-02-27 20:21:34 +01:00
// If 'messages' table does not exist, this must be a new database
rowsMC, err := db.Query(selectMessagesCountQuery)
if err != nil {
return setupNewCacheDB(db)
}
rowsMC.Close()
// If 'messages' table exists, check 'schemaVersion' table
schemaVersion := 0
rowsSV, err := db.Query(selectSchemaVersionQuery)
if err == nil {
defer rowsSV.Close()
if !rowsSV.Next() {
return errors.New("cannot determine schema version: cache file may be corrupt")
}
if err := rowsSV.Scan(&schemaVersion); err != nil {
return err
}
rowsSV.Close()
}
// Do migrations
if schemaVersion == currentSchemaVersion {
return nil
} else if schemaVersion == 0 {
return migrateFrom0(db)
} else if schemaVersion == 1 {
return migrateFrom1(db)
} else if schemaVersion == 2 {
return migrateFrom2(db)
} else if schemaVersion == 3 {
return migrateFrom3(db)
} else if schemaVersion == 4 {
return migrateFrom4(db)
2022-04-21 15:58:28 +02:00
} else if schemaVersion == 5 {
return migrateFrom5(db)
} else if schemaVersion == 6 {
return migrateFrom6(db)
2022-07-16 21:31:03 +02:00
} else if schemaVersion == 7 {
return migrateFrom7(db)
2022-02-27 20:21:34 +01:00
}
return fmt.Errorf("unexpected schema version found: %d", schemaVersion)
}
func setupNewCacheDB(db *sql.DB) error {
if _, err := db.Exec(createMessagesTableQuery); err != nil {
return err
}
if _, err := db.Exec(createSchemaVersionTableQuery); err != nil {
return err
}
if _, err := db.Exec(insertSchemaVersion, currentSchemaVersion); err != nil {
return err
}
return nil
}
func migrateFrom0(db *sql.DB) error {
log.Info("Migrating cache database schema: from 0 to 1")
2022-02-27 20:21:34 +01:00
if _, err := db.Exec(migrate0To1AlterMessagesTableQuery); err != nil {
return err
}
if _, err := db.Exec(createSchemaVersionTableQuery); err != nil {
return err
}
if _, err := db.Exec(insertSchemaVersion, 1); err != nil {
return err
}
return migrateFrom1(db)
}
func migrateFrom1(db *sql.DB) error {
log.Info("Migrating cache database schema: from 1 to 2")
2022-02-27 20:21:34 +01:00
if _, err := db.Exec(migrate1To2AlterMessagesTableQuery); err != nil {
return err
}
if _, err := db.Exec(updateSchemaVersion, 2); err != nil {
return err
}
return migrateFrom2(db)
}
func migrateFrom2(db *sql.DB) error {
log.Info("Migrating cache database schema: from 2 to 3")
2022-02-27 20:21:34 +01:00
if _, err := db.Exec(migrate2To3AlterMessagesTableQuery); err != nil {
return err
}
if _, err := db.Exec(updateSchemaVersion, 3); err != nil {
return err
}
return migrateFrom3(db)
}
func migrateFrom3(db *sql.DB) error {
log.Info("Migrating cache database schema: from 3 to 4")
2022-02-27 20:21:34 +01:00
if _, err := db.Exec(migrate3To4AlterMessagesTableQuery); err != nil {
return err
}
if _, err := db.Exec(updateSchemaVersion, 4); err != nil {
return err
}
return migrateFrom4(db)
}
func migrateFrom4(db *sql.DB) error {
log.Info("Migrating cache database schema: from 4 to 5")
2022-02-27 20:21:34 +01:00
if _, err := db.Exec(migrate4To5AlterMessagesTableQuery); err != nil {
return err
}
if _, err := db.Exec(updateSchemaVersion, 5); err != nil {
return err
}
2022-04-21 15:58:28 +02:00
return migrateFrom5(db)
}
func migrateFrom5(db *sql.DB) error {
log.Info("Migrating cache database schema: from 5 to 6")
2022-04-21 15:58:28 +02:00
if _, err := db.Exec(migrate5To6AlterMessagesTableQuery); err != nil {
return err
}
if _, err := db.Exec(updateSchemaVersion, 6); err != nil {
return err
}
return migrateFrom6(db)
}
func migrateFrom6(db *sql.DB) error {
log.Info("Migrating cache database schema: from 6 to 7")
if _, err := db.Exec(migrate6To7AlterMessagesTableQuery); err != nil {
return err
}
if _, err := db.Exec(updateSchemaVersion, 7); err != nil {
return err
}
2022-07-16 21:31:03 +02:00
return migrateFrom7(db)
}
func migrateFrom7(db *sql.DB) error {
log.Info("Migrating cache database schema: from 7 to 8")
if _, err := db.Exec(migrate7To8AlterMessagesTableQuery); err != nil {
return err
}
if _, err := db.Exec(updateSchemaVersion, 8); err != nil {
return err
}
2022-02-27 20:21:34 +01:00
return nil // Update this when a new version is added
2021-11-02 19:08:21 +01:00
}