migrate to multiple sqlite db files ( primary + requests + logs )

scnserver/db/impl/logs/database.go

@@ -0,0 +1,111 @@
+package logs
+
+import (
+	server "blackforestbytes.com/simplecloudnotifier"
+	"blackforestbytes.com/simplecloudnotifier/db/dbtools"
+	"blackforestbytes.com/simplecloudnotifier/db/impl/logs/schema"
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"github.com/jmoiron/sqlx"
+	_ "github.com/mattn/go-sqlite3"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+	"time"
+)
+
+type Database struct {
+	db  sq.DB
+	pp  *dbtools.DBPreprocessor
+	wal bool
+}
+
+func NewLogsDatabase(cfg server.Config) (*Database, error) {
+	conf := cfg.DBLogs
+
+	url := fmt.Sprintf("file:%s?_journal=%s&_timeout=%d&_fk=%s", conf.File, conf.Journal, conf.Timeout.Milliseconds(), langext.FormatBool(conf.CheckForeignKeys, "true", "false"))
+
+	xdb, err := sqlx.Open("sqlite3", url)
+	if err != nil {
+		return nil, err
+	}
+
+	if conf.SingleConn {
+		xdb.SetMaxOpenConns(1)
+	} else {
+		xdb.SetMaxOpenConns(5)
+		xdb.SetMaxIdleConns(5)
+		xdb.SetConnMaxLifetime(60 * time.Minute)
+		xdb.SetConnMaxIdleTime(60 * time.Minute)
+	}
+
+	qqdb := sq.NewDB(xdb)
+
+	qqdb.AddListener(dbtools.DBLogger{})
+
+	pp, err := dbtools.NewDBPreprocessor(qqdb)
+	if err != nil {
+		return nil, err
+	}
+
+	qqdb.AddListener(pp)
+
+	scndb := &Database{db: qqdb, pp: pp, wal: conf.Journal == "WAL"}
+
+	return scndb, nil
+}
+
+func (db *Database) Migrate(ctx context.Context) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 24*time.Second)
+	defer cancel()
+
+	currschema, err := db.ReadSchema(ctx)
+	if currschema == 0 {
+
+		_, err = db.db.Exec(ctx, schema.LogsSchema1, sq.PP{})
+		if err != nil {
+			return err
+		}
+
+		err = db.WriteMetaInt(ctx, "schema", 1)
+		if err != nil {
+			return err
+		}
+
+		err = db.pp.Init(ctx)
+		if err != nil {
+			return err
+		}
+
+		return nil
+
+	} else if currschema == 1 {
+		return nil // current
+	} else {
+		return errors.New(fmt.Sprintf("Unknown DB schema: %d", currschema))
+	}
+
+}
+
+func (db *Database) Ping(ctx context.Context) error {
+	return db.db.Ping(ctx)
+}
+
+func (db *Database) BeginTx(ctx context.Context) (sq.Tx, error) {
+	return db.db.BeginTransaction(ctx, sql.LevelDefault)
+}
+
+func (db *Database) Stop(ctx context.Context) error {
+	if db.wal {
+		_, err := db.db.Exec(ctx, "PRAGMA wal_checkpoint;", sq.PP{})
+		if err != nil {
+			return err
+		}
+	}
+	err := db.db.Exit()
+	if err != nil {
+		return err
+	}
+	return nil
+}

scnserver/db/impl/logs/meta.go

@@ -0,0 +1,242 @@
+package logs
+
+import (
+	"context"
+	"errors"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+)
+
+func (db *Database) ReadSchema(ctx context.Context) (retval int, reterr error) {
+
+	r1, err := db.db.Query(ctx, "SELECT name FROM sqlite_master WHERE type = :typ AND name = :name", sq.PP{"typ": "table", "name": "meta"})
+	if err != nil {
+		return 0, err
+	}
+	defer func() {
+		err = r1.Close()
+		if err != nil {
+			// overwrite return values
+			retval = 0
+			reterr = err
+		}
+	}()
+
+	if !r1.Next() {
+		return 0, nil
+	}
+
+	err = r1.Close()
+	if err != nil {
+		return 0, err
+	}
+
+	r2, err := db.db.Query(ctx, "SELECT value_int FROM meta WHERE meta_key = :key", sq.PP{"key": "schema"})
+	if err != nil {
+		return 0, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = 0
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return 0, errors.New("no schema entry in meta table")
+	}
+
+	var dbschema int
+	err = r2.Scan(&dbschema)
+	if err != nil {
+		return 0, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return 0, err
+	}
+
+	return dbschema, nil
+}
+
+func (db *Database) WriteMetaString(ctx context.Context, key string, value string) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_txt) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_txt = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) WriteMetaInt(ctx context.Context, key string, value int64) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_int) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_int = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) WriteMetaReal(ctx context.Context, key string, value float64) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_real) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_real = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) WriteMetaBlob(ctx context.Context, key string, value []byte) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_blob) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_blob = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) ReadMetaString(ctx context.Context, key string) (retval *string, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_txt FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value string
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) ReadMetaInt(ctx context.Context, key string) (retval *int64, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_int FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value int64
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) ReadMetaReal(ctx context.Context, key string) (retval *float64, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_real FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value float64
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) ReadMetaBlob(ctx context.Context, key string) (retval *[]byte, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_blob FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value []byte
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) DeleteMeta(ctx context.Context, key string) error {
+	_, err := db.db.Exec(ctx, "DELETE FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return err
+	}
+	return nil
+}

scnserver/db/impl/logs/schema/assets.go

@@ -0,0 +1,6 @@
+package schema
+
+import _ "embed"
+
+//go:embed schema_1.ddl
+var LogsSchema1 string

scnserver/db/impl/logs/schema/schema_1.ddl

@@ -0,0 +1,22 @@
+
+CREATE TABLE `logs`
+(
+    log_id               INTEGER        PRIMARY KEY,
+    timestamp_created    INTEGER        NOT NULL
+
+) STRICT;
+
+
+CREATE TABLE `meta`
+(
+    meta_key     TEXT       NOT NULL,
+    value_int    INTEGER        NULL,
+    value_txt    TEXT           NULL,
+    value_real   REAL           NULL,
+    value_blob   BLOB           NULL,
+
+    PRIMARY KEY (meta_key)
+) STRICT;
+
+
+INSERT INTO meta (meta_key, value_int) VALUES ('schema', 1)

scnserver/db/impl/logs/schema/schema_sqlite.ddl

@@ -0,0 +1,7 @@
+CREATE TABLE sqlite_master (
+    type text,
+    name text,
+    tbl_name text,
+    rootpage integer,
+    sql text
+);

scnserver/db/impl/logs/utils.go

@@ -0,0 +1,25 @@
+package logs
+
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"time"
+)
+
+func bool2DB(b bool) int {
+	if b {
+		return 1
+	} else {
+		return 0
+	}
+}
+
+func time2DB(t time.Time) int64 {
+	return t.UnixMilli()
+}
+
+func time2DBOpt(t *time.Time) *int64 {
+	if t == nil {
+		return nil
+	}
+	return langext.Ptr(t.UnixMilli())
+}

scnserver/db/impl/primary/channels.go

@@ -0,0 +1,291 @@
+package primary
+
+import (
+	"blackforestbytes.com/simplecloudnotifier/models"
+	"database/sql"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+	"time"
+)
+
+func (db *Database) GetChannelByName(ctx TxContext, userid models.UserID, chanName string) (*models.Channel, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM channels WHERE owner_user_id = :uid AND internal_name = :nam LIMIT 1", sq.PP{
+		"uid": userid,
+		"nam": chanName,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	channel, err := models.DecodeChannel(rows)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &channel, nil
+}
+
+func (db *Database) GetChannelByNameAndSendKey(ctx TxContext, chanName string, sendKey string) (*models.Channel, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM channels WHERE internal_name = :chan_name OR send_key = :send_key LIMIT 1", sq.PP{
+		"chan_name": chanName,
+		"send_key":  sendKey,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	channel, err := models.DecodeChannel(rows)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &channel, nil
+}
+
+func (db *Database) GetChannelByID(ctx TxContext, chanid models.ChannelID) (*models.Channel, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM channels WHERE channel_id = :cid LIMIT 1", sq.PP{
+		"cid": chanid,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	channel, err := models.DecodeChannel(rows)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &channel, nil
+}
+
+func (db *Database) CreateChannel(ctx TxContext, userid models.UserID, dispName string, intName string, subscribeKey string, sendKey string) (models.Channel, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.Channel{}, err
+	}
+
+	now := time.Now().UTC()
+
+	res, err := tx.Exec(ctx, "INSERT INTO channels (owner_user_id, display_name, internal_name, subscribe_key, send_key, timestamp_created) VALUES (:ouid, :dnam, :inam, :subkey, :sendkey, :ts)", sq.PP{
+		"ouid":    userid,
+		"dnam":    dispName,
+		"inam":    intName,
+		"subkey":  subscribeKey,
+		"sendkey": sendKey,
+		"ts":      time2DB(now),
+	})
+	if err != nil {
+		return models.Channel{}, err
+	}
+
+	liid, err := res.LastInsertId()
+	if err != nil {
+		return models.Channel{}, err
+	}
+
+	return models.Channel{
+		ChannelID:         models.ChannelID(liid),
+		OwnerUserID:       userid,
+		DisplayName:       dispName,
+		InternalName:      intName,
+		SubscribeKey:      subscribeKey,
+		SendKey:           sendKey,
+		TimestampCreated:  now,
+		TimestampLastSent: nil,
+		MessagesSent:      0,
+	}, nil
+}
+
+func (db *Database) ListChannelsByOwner(ctx TxContext, userid models.UserID, subUserID models.UserID) ([]models.ChannelWithSubscription, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT channels.*, sub.* FROM channels LEFT JOIN subscriptions AS sub ON channels.channel_id = sub.channel_id AND sub.subscriber_user_id = :subuid WHERE owner_user_id = :ouid", sq.PP{
+		"ouid":   userid,
+		"subuid": subUserID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := models.DecodeChannelsWithSubscription(rows)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func (db *Database) ListChannelsBySubscriber(ctx TxContext, userid models.UserID, confirmed *bool) ([]models.ChannelWithSubscription, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	confCond := ""
+	if confirmed != nil && *confirmed {
+		confCond = " AND sub.confirmed = 1"
+	} else if confirmed != nil && !*confirmed {
+		confCond = " AND sub.confirmed = 0"
+	}
+
+	rows, err := tx.Query(ctx, "SELECT channels.*, sub.* FROM channels LEFT JOIN subscriptions AS sub on channels.channel_id = sub.channel_id AND sub.subscriber_user_id = :subuid WHERE sub.subscription_id IS NOT NULL "+confCond, sq.PP{
+		"subuid": userid,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := models.DecodeChannelsWithSubscription(rows)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func (db *Database) ListChannelsByAccess(ctx TxContext, userid models.UserID, confirmed *bool) ([]models.ChannelWithSubscription, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	confCond := "OR (sub.subscription_id IS NOT NULL)"
+	if confirmed != nil && *confirmed {
+		confCond = "OR (sub.subscription_id IS NOT NULL AND sub.confirmed = 1)"
+	} else if confirmed != nil && !*confirmed {
+		confCond = "OR (sub.subscription_id IS NOT NULL AND sub.confirmed = 0)"
+	}
+
+	rows, err := tx.Query(ctx, "SELECT channels.*, sub.* FROM channels LEFT JOIN subscriptions AS sub on channels.channel_id = sub.channel_id AND sub.subscriber_user_id = :subuid WHERE owner_user_id = :ouid "+confCond, sq.PP{
+		"ouid":   userid,
+		"subuid": userid,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := models.DecodeChannelsWithSubscription(rows)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func (db *Database) GetChannel(ctx TxContext, userid models.UserID, channelid models.ChannelID) (models.ChannelWithSubscription, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.ChannelWithSubscription{}, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT channels.*, sub.* FROM channels LEFT JOIN subscriptions AS sub on channels.channel_id = sub.channel_id AND sub.subscriber_user_id = :subuid WHERE owner_user_id = :ouid AND channels.channel_id = :cid LIMIT 1", sq.PP{
+		"ouid":   userid,
+		"cid":    channelid,
+		"subuid": userid,
+	})
+	if err != nil {
+		return models.ChannelWithSubscription{}, err
+	}
+
+	channel, err := models.DecodeChannelWithSubscription(rows)
+	if err != nil {
+		return models.ChannelWithSubscription{}, err
+	}
+
+	return channel, nil
+}
+
+func (db *Database) IncChannelMessageCounter(ctx TxContext, channel models.Channel) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE channels SET messages_sent = :ctr, timestamp_lastsent = :ts WHERE channel_id = :cid", sq.PP{
+		"ctr": channel.MessagesSent + 1,
+		"cid": time2DB(time.Now()),
+		"ts":  channel.ChannelID,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) UpdateChannelSendKey(ctx TxContext, channelid models.ChannelID, newkey string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE channels SET send_key = :key WHERE channel_id = :cid", sq.PP{
+		"key": newkey,
+		"cid": channelid,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) UpdateChannelSubscribeKey(ctx TxContext, channelid models.ChannelID, newkey string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE channels SET subscribe_key = :key WHERE channel_id = :cid", sq.PP{
+		"key": newkey,
+		"cid": channelid,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) UpdateChannelDisplayName(ctx TxContext, channelid models.ChannelID, dispname string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE channels SET display_name = :nam WHERE channel_id = :cid", sq.PP{
+		"nam": dispname,
+		"cid": channelid,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

scnserver/db/impl/primary/clients.go

@@ -0,0 +1,127 @@
+package primary
+
+import (
+	"blackforestbytes.com/simplecloudnotifier/models"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+	"time"
+)
+
+func (db *Database) CreateClient(ctx TxContext, userid models.UserID, ctype models.ClientType, fcmToken string, agentModel string, agentVersion string) (models.Client, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.Client{}, err
+	}
+
+	now := time.Now().UTC()
+
+	res, err := tx.Exec(ctx, "INSERT INTO clients (user_id, type, fcm_token, timestamp_created, agent_model, agent_version) VALUES (:uid, :typ, :fcm, :ts, :am, :av)", sq.PP{
+		"uid": userid,
+		"typ": string(ctype),
+		"fcm": fcmToken,
+		"ts":  time2DB(now),
+		"am":  agentModel,
+		"av":  agentVersion,
+	})
+	if err != nil {
+		return models.Client{}, err
+	}
+
+	liid, err := res.LastInsertId()
+	if err != nil {
+		return models.Client{}, err
+	}
+
+	return models.Client{
+		ClientID:         models.ClientID(liid),
+		UserID:           userid,
+		Type:             ctype,
+		FCMToken:         langext.Ptr(fcmToken),
+		TimestampCreated: now,
+		AgentModel:       agentModel,
+		AgentVersion:     agentVersion,
+	}, nil
+}
+
+func (db *Database) ClearFCMTokens(ctx TxContext, fcmtoken string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "DELETE FROM clients WHERE fcm_token = :fcm", sq.PP{"fcm": fcmtoken})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) ListClients(ctx TxContext, userid models.UserID) ([]models.Client, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM clients WHERE user_id = :uid", sq.PP{"uid": userid})
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := models.DecodeClients(rows)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func (db *Database) GetClient(ctx TxContext, userid models.UserID, clientid models.ClientID) (models.Client, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.Client{}, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM clients WHERE user_id = :uid AND client_id = :cid LIMIT 1", sq.PP{
+		"uid": userid,
+		"cid": clientid,
+	})
+	if err != nil {
+		return models.Client{}, err
+	}
+
+	client, err := models.DecodeClient(rows)
+	if err != nil {
+		return models.Client{}, err
+	}
+
+	return client, nil
+}
+
+func (db *Database) DeleteClient(ctx TxContext, clientid models.ClientID) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "DELETE FROM clients WHERE client_id = :cid", sq.PP{"cid": clientid})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) DeleteClientsByFCM(ctx TxContext, fcmtoken string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "DELETE FROM clients WHERE fcm_token = :fcm", sq.PP{"fcm": fcmtoken})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

scnserver/db/impl/primary/context.go

@@ -0,0 +1,16 @@
+package primary
+
+import (
+	"blackforestbytes.com/simplecloudnotifier/db"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+	"time"
+)
+
+type TxContext interface {
+	Deadline() (deadline time.Time, ok bool)
+	Done() <-chan struct{}
+	Err() error
+	Value(key any) any
+
+	GetOrCreateTransaction(db db.DatabaseImpl) (sq.Tx, error)
+}

scnserver/db/impl/primary/database.go

@@ -0,0 +1,115 @@
+package primary
+
+import (
+	server "blackforestbytes.com/simplecloudnotifier"
+	"blackforestbytes.com/simplecloudnotifier/db/dbtools"
+	"blackforestbytes.com/simplecloudnotifier/db/impl/primary/schema"
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"github.com/jmoiron/sqlx"
+	_ "github.com/mattn/go-sqlite3"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+	"time"
+)
+
+type Database struct {
+	db  sq.DB
+	pp  *dbtools.DBPreprocessor
+	wal bool
+}
+
+func NewPrimaryDatabase(cfg server.Config) (*Database, error) {
+	conf := cfg.DBMain
+
+	url := fmt.Sprintf("file:%s?_journal=%s&_timeout=%d&_fk=%s", conf.File, conf.Journal, conf.Timeout.Milliseconds(), langext.FormatBool(conf.CheckForeignKeys, "true", "false"))
+
+	xdb, err := sqlx.Open("sqlite3", url)
+	if err != nil {
+		return nil, err
+	}
+
+	if conf.SingleConn {
+		xdb.SetMaxOpenConns(1)
+	} else {
+		xdb.SetMaxOpenConns(5)
+		xdb.SetMaxIdleConns(5)
+		xdb.SetConnMaxLifetime(60 * time.Minute)
+		xdb.SetConnMaxIdleTime(60 * time.Minute)
+	}
+
+	qqdb := sq.NewDB(xdb)
+
+	qqdb.AddListener(dbtools.DBLogger{})
+
+	pp, err := dbtools.NewDBPreprocessor(qqdb)
+	if err != nil {
+		return nil, err
+	}
+
+	qqdb.AddListener(pp)
+
+	scndb := &Database{db: qqdb, pp: pp, wal: conf.Journal == "WAL"}
+
+	return scndb, nil
+}
+
+func (db *Database) Migrate(ctx context.Context) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 24*time.Second)
+	defer cancel()
+
+	currschema, err := db.ReadSchema(ctx)
+	if currschema == 0 {
+
+		_, err = db.db.Exec(ctx, schema.PrimarySchema3, sq.PP{})
+		if err != nil {
+			return err
+		}
+
+		err = db.WriteMetaInt(ctx, "schema", 3)
+		if err != nil {
+			return err
+		}
+
+		err = db.pp.Init(ctx)
+		if err != nil {
+			return err
+		}
+
+		return nil
+
+	} else if currschema == 1 {
+		return errors.New("cannot autom. upgrade schema 1")
+	} else if currschema == 2 {
+		return errors.New("cannot autom. upgrade schema 2") //TODO
+	} else if currschema == 3 {
+		return nil // current
+	} else {
+		return errors.New(fmt.Sprintf("Unknown DB schema: %d", currschema))
+	}
+
+}
+
+func (db *Database) Ping(ctx context.Context) error {
+	return db.db.Ping(ctx)
+}
+
+func (db *Database) BeginTx(ctx context.Context) (sq.Tx, error) {
+	return db.db.BeginTransaction(ctx, sql.LevelDefault)
+}
+
+func (db *Database) Stop(ctx context.Context) error {
+	if db.wal {
+		_, err := db.db.Exec(ctx, "PRAGMA wal_checkpoint;", sq.PP{})
+		if err != nil {
+			return err
+		}
+	}
+	err := db.db.Exit()
+	if err != nil {
+		return err
+	}
+	return nil
+}

scnserver/db/impl/primary/deliveries.go

@@ -0,0 +1,187 @@
+package primary
+
+import (
+	scn "blackforestbytes.com/simplecloudnotifier"
+	"blackforestbytes.com/simplecloudnotifier/models"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+	"time"
+)
+
+func (db *Database) CreateRetryDelivery(ctx TxContext, client models.Client, msg models.Message) (models.Delivery, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.Delivery{}, err
+	}
+
+	now := time.Now().UTC()
+	next := scn.NextDeliveryTimestamp(now)
+
+	res, err := tx.Exec(ctx, "INSERT INTO deliveries (scn_message_id, receiver_user_id, receiver_client_id, timestamp_created, timestamp_finalized, status, fcm_message_id, next_delivery) VALUES (:mid, :ruid, :rcid, :tsc, :tsf, :stat, :fcm, :next)", sq.PP{
+		"mid":  msg.SCNMessageID,
+		"ruid": client.UserID,
+		"rcid": client.ClientID,
+		"tsc":  time2DB(now),
+		"tsf":  nil,
+		"stat": models.DeliveryStatusRetry,
+		"fcm":  nil,
+		"next": time2DB(next),
+	})
+	if err != nil {
+		return models.Delivery{}, err
+	}
+
+	liid, err := res.LastInsertId()
+	if err != nil {
+		return models.Delivery{}, err
+	}
+
+	return models.Delivery{
+		DeliveryID:         models.DeliveryID(liid),
+		SCNMessageID:       msg.SCNMessageID,
+		ReceiverUserID:     client.UserID,
+		ReceiverClientID:   client.ClientID,
+		TimestampCreated:   now,
+		TimestampFinalized: nil,
+		Status:             models.DeliveryStatusRetry,
+		RetryCount:         0,
+		NextDelivery:       langext.Ptr(next),
+		FCMMessageID:       nil,
+	}, nil
+}
+
+func (db *Database) CreateSuccessDelivery(ctx TxContext, client models.Client, msg models.Message, fcmDelivID string) (models.Delivery, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.Delivery{}, err
+	}
+
+	now := time.Now().UTC()
+
+	res, err := tx.Exec(ctx, "INSERT INTO deliveries (scn_message_id, receiver_user_id, receiver_client_id, timestamp_created, timestamp_finalized, status, fcm_message_id, next_delivery) VALUES (:mid, :ruid, :rcid, :tsc, :tsf, :stat, :fcm, :next)", sq.PP{
+		"mid":  msg.SCNMessageID,
+		"ruid": client.UserID,
+		"rcid": client.ClientID,
+		"tsc":  time2DB(now),
+		"tsf":  time2DB(now),
+		"stat": models.DeliveryStatusSuccess,
+		"fcm":  fcmDelivID,
+		"next": nil,
+	})
+	if err != nil {
+		return models.Delivery{}, err
+	}
+
+	liid, err := res.LastInsertId()
+	if err != nil {
+		return models.Delivery{}, err
+	}
+
+	return models.Delivery{
+		DeliveryID:         models.DeliveryID(liid),
+		SCNMessageID:       msg.SCNMessageID,
+		ReceiverUserID:     client.UserID,
+		ReceiverClientID:   client.ClientID,
+		TimestampCreated:   now,
+		TimestampFinalized: langext.Ptr(now),
+		Status:             models.DeliveryStatusSuccess,
+		RetryCount:         0,
+		NextDelivery:       nil,
+		FCMMessageID:       langext.Ptr(fcmDelivID),
+	}, nil
+}
+
+func (db *Database) ListRetrieableDeliveries(ctx TxContext, pageSize int) ([]models.Delivery, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM deliveries WHERE status = 'RETRY' AND next_delivery < :next LIMIT :lim", sq.PP{
+		"next": time2DB(time.Now()),
+		"lim":  pageSize,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := models.DecodeDeliveries(rows)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func (db *Database) SetDeliverySuccess(ctx TxContext, delivery models.Delivery, fcmDelivID string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE deliveries SET status = 'SUCCESS', next_delivery = NULL, retry_count = :rc, timestamp_finalized = :ts, fcm_message_id = :fcm WHERE delivery_id = :did", sq.PP{
+		"rc":  delivery.RetryCount + 1,
+		"ts":  time2DB(time.Now()),
+		"fcm": fcmDelivID,
+		"did": delivery.DeliveryID,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) SetDeliveryFailed(ctx TxContext, delivery models.Delivery) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE deliveries SET status = 'FAILED', next_delivery = NULL, retry_count = :rc, timestamp_finalized = :ts WHERE delivery_id = :did",
+		sq.PP{
+			"rc":  delivery.RetryCount + 1,
+			"ts":  time2DB(time.Now()),
+			"did": delivery.DeliveryID,
+		})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) SetDeliveryRetry(ctx TxContext, delivery models.Delivery) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE deliveries SET status = 'RETRY', next_delivery = :next, retry_count = :rc WHERE delivery_id = :did", sq.PP{
+		"next": scn.NextDeliveryTimestamp(time.Now()),
+		"rc":   delivery.RetryCount + 1,
+		"did":  delivery.DeliveryID,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) CancelPendingDeliveries(ctx TxContext, scnMessageID models.SCNMessageID) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE deliveries SET status = 'FAILED', next_delivery = NULL, timestamp_finalized = :ts WHERE scn_message_id = :mid AND status = 'RETRY'", sq.PP{
+		"ts":  time.Now(),
+		"mid": scnMessageID,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

scnserver/db/impl/primary/messages.go

@@ -0,0 +1,162 @@
+package primary
+
+import (
+	"blackforestbytes.com/simplecloudnotifier/db/cursortoken"
+	"blackforestbytes.com/simplecloudnotifier/models"
+	"database/sql"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+	"time"
+)
+
+func (db *Database) GetMessageByUserMessageID(ctx TxContext, usrMsgId string) (*models.Message, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM messages WHERE usr_message_id = :umid LIMIT 1", sq.PP{"umid": usrMsgId})
+	if err != nil {
+		return nil, err
+	}
+
+	msg, err := models.DecodeMessage(rows)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &msg, nil
+}
+
+func (db *Database) GetMessage(ctx TxContext, scnMessageID models.SCNMessageID, allowDeleted bool) (models.Message, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.Message{}, err
+	}
+
+	var sqlcmd string
+	if allowDeleted {
+		sqlcmd = "SELECT * FROM messages WHERE scn_message_id = :mid LIMIT 1"
+	} else {
+		sqlcmd = "SELECT * FROM messages WHERE scn_message_id = :mid AND deleted=0 LIMIT 1"
+	}
+
+	rows, err := tx.Query(ctx, sqlcmd, sq.PP{"mid": scnMessageID})
+	if err != nil {
+		return models.Message{}, err
+	}
+
+	msg, err := models.DecodeMessage(rows)
+	if err != nil {
+		return models.Message{}, err
+	}
+
+	return msg, nil
+}
+
+func (db *Database) CreateMessage(ctx TxContext, senderUserID models.UserID, channel models.Channel, timestampSend *time.Time, title string, content *string, priority int, userMsgId *string, senderIP string, senderName *string) (models.Message, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.Message{}, err
+	}
+
+	now := time.Now().UTC()
+
+	res, err := tx.Exec(ctx, "INSERT INTO messages (sender_user_id, owner_user_id, channel_internal_name, channel_id, timestamp_real, timestamp_client, title, content, priority, usr_message_id, sender_ip, sender_name) VALUES (:suid, :ouid, :cnam, :cid, :tsr, :tsc, :tit, :cnt, :prio, :umid, :ip, :snam)", sq.PP{
+		"suid": senderUserID,
+		"ouid": channel.OwnerUserID,
+		"cnam": channel.InternalName,
+		"cid":  channel.ChannelID,
+		"tsr":  time2DB(now),
+		"tsc":  time2DBOpt(timestampSend),
+		"tit":  title,
+		"cnt":  content,
+		"prio": priority,
+		"umid": userMsgId,
+		"ip":   senderIP,
+		"snam": senderName,
+	})
+	if err != nil {
+		return models.Message{}, err
+	}
+
+	liid, err := res.LastInsertId()
+	if err != nil {
+		return models.Message{}, err
+	}
+
+	return models.Message{
+		SCNMessageID:        models.SCNMessageID(liid),
+		SenderUserID:        senderUserID,
+		OwnerUserID:         channel.OwnerUserID,
+		ChannelInternalName: channel.InternalName,
+		ChannelID:           channel.ChannelID,
+		SenderIP:            senderIP,
+		SenderName:          senderName,
+		TimestampReal:       now,
+		TimestampClient:     timestampSend,
+		Title:               title,
+		Content:             content,
+		Priority:            priority,
+		UserMessageID:       userMsgId,
+	}, nil
+}
+
+func (db *Database) DeleteMessage(ctx TxContext, scnMessageID models.SCNMessageID) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE messages SET deleted=1 WHERE scn_message_id = :mid AND deleted=0", sq.PP{"mid": scnMessageID})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) ListMessages(ctx TxContext, filter models.MessageFilter, pageSize int, inTok cursortoken.CursorToken) ([]models.Message, cursortoken.CursorToken, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, cursortoken.CursorToken{}, err
+	}
+
+	if inTok.Mode == cursortoken.CTMEnd {
+		return make([]models.Message, 0), cursortoken.End(), nil
+	}
+
+	pageCond := "1=1"
+	if inTok.Mode == cursortoken.CTMNormal {
+		pageCond = "timestamp_real < :tokts OR (timestamp_real = :tokts AND scn_message_id < :tokid )"
+	}
+
+	filterCond, filterJoin, prepParams, err := filter.SQL()
+
+	orderClause := "ORDER BY COALESCE(timestamp_client, timestamp_real) DESC LIMIT :lim"
+
+	sqlQuery := "SELECT " + "messages.*" + " FROM messages " + filterJoin + " WHERE ( " + pageCond + " ) AND ( " + filterCond + " ) " + orderClause
+
+	prepParams["lim"] = pageSize + 1
+	prepParams["tokts"] = inTok.Timestamp
+	prepParams["tokid"] = inTok.Id
+
+	rows, err := tx.Query(ctx, sqlQuery, prepParams)
+	if err != nil {
+		return nil, cursortoken.CursorToken{}, err
+	}
+
+	data, err := models.DecodeMessages(rows)
+	if err != nil {
+		return nil, cursortoken.CursorToken{}, err
+	}
+
+	if len(data) <= pageSize {
+		return data, cursortoken.End(), nil
+	} else {
+		outToken := cursortoken.Normal(data[pageSize-1].Timestamp(), data[pageSize-1].SCNMessageID.IntID(), "DESC", filter.Hash())
+		return data[0:pageSize], outToken, nil
+	}
+}

scnserver/db/impl/primary/meta.go

@@ -0,0 +1,242 @@
+package primary
+
+import (
+	"context"
+	"errors"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+)
+
+func (db *Database) ReadSchema(ctx context.Context) (retval int, reterr error) {
+
+	r1, err := db.db.Query(ctx, "SELECT name FROM sqlite_master WHERE type = :typ AND name = :name", sq.PP{"typ": "table", "name": "meta"})
+	if err != nil {
+		return 0, err
+	}
+	defer func() {
+		err = r1.Close()
+		if err != nil {
+			// overwrite return values
+			retval = 0
+			reterr = err
+		}
+	}()
+
+	if !r1.Next() {
+		return 0, nil
+	}
+
+	err = r1.Close()
+	if err != nil {
+		return 0, err
+	}
+
+	r2, err := db.db.Query(ctx, "SELECT value_int FROM meta WHERE meta_key = :key", sq.PP{"key": "schema"})
+	if err != nil {
+		return 0, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = 0
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return 0, errors.New("no schema entry in meta table")
+	}
+
+	var dbschema int
+	err = r2.Scan(&dbschema)
+	if err != nil {
+		return 0, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return 0, err
+	}
+
+	return dbschema, nil
+}
+
+func (db *Database) WriteMetaString(ctx context.Context, key string, value string) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_txt) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_txt = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) WriteMetaInt(ctx context.Context, key string, value int64) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_int) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_int = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) WriteMetaReal(ctx context.Context, key string, value float64) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_real) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_real = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) WriteMetaBlob(ctx context.Context, key string, value []byte) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_blob) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_blob = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) ReadMetaString(ctx context.Context, key string) (retval *string, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_txt FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value string
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) ReadMetaInt(ctx context.Context, key string) (retval *int64, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_int FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value int64
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) ReadMetaReal(ctx context.Context, key string) (retval *float64, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_real FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value float64
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) ReadMetaBlob(ctx context.Context, key string) (retval *[]byte, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_blob FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value []byte
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) DeleteMeta(ctx context.Context, key string) error {
+	_, err := db.db.Exec(ctx, "DELETE FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return err
+	}
+	return nil
+}

scnserver/db/impl/primary/schema/assets.go

@@ -0,0 +1,12 @@
+package schema
+
+import _ "embed"
+
+//go:embed schema_1.ddl
+var PrimarySchema1 string
+
+//go:embed schema_2.ddl
+var PrimarySchema2 string
+
+//go:embed schema_3.ddl
+var PrimarySchema3 string

scnserver/db/impl/primary/schema/schema_1.ddl

@@ -0,0 +1,38 @@
+DROP TABLE IF EXISTS `users`;
+CREATE TABLE `users`
+(
+    `user_id`            INT(11)         NOT NULL   AUTO_INCREMENT,
+    `user_key`           VARCHAR(64)     NOT NULL,
+    `fcm_token`          VARCHAR(256)        NULL   DEFAULT NULL,
+    `messages_sent`      INT(11)         NOT NULL   DEFAULT '0',
+    `timestamp_created`  DATETIME        NOT NULL   DEFAULT CURRENT_TIMESTAMP,
+    `timestamp_accessed` DATETIME            NULL   DEFAULT NULL,
+
+    `quota_today`        INT(11)         NOT NULL   DEFAULT '0',
+    `quota_day`          DATE                NULL   DEFAULT NULL,
+
+    `is_pro`             BIT             NOT NULL   DEFAULT 0,
+    `pro_token`          VARCHAR(256)        NULL   DEFAULT NULL,
+
+    PRIMARY KEY (`user_id`)
+);
+
+DROP TABLE IF EXISTS `messages`;
+CREATE TABLE `messages`
+(
+    `scn_message_id`     INT(11)         NOT NULL   AUTO_INCREMENT,
+    `sender_user_id`     INT(11)         NOT NULL,
+
+    `timestamp_real`     DATETIME        NOT NULL   DEFAULT CURRENT_TIMESTAMP,
+    `ack`                TINYINT(1)      NOT NULL   DEFAULT 0,
+
+    `title`              VARCHAR(256)    NOT NULL,
+    `content`            LONGTEXT            NULL,
+    `priority`           INT(11)         NOT NULL,
+    `sendtime`           BIGINT UNSIGNED NOT NULL,
+
+    `fcm_message_id`     VARCHAR(256)        NULL,
+    `usr_message_id`     VARCHAR(256)        NULL,
+
+    PRIMARY KEY (`scn_message_id`)
+);

scnserver/db/impl/primary/schema/schema_2.ddl

@@ -0,0 +1,47 @@
+CREATE TABLE `users`
+(
+    `user_id`            INTEGER                AUTO_INCREMENT,
+    `user_key`           TEXT         NOT NULL,
+    `fcm_token`          TEXT             NULL  DEFAULT NULL,
+    `messages_sent`      INTEGER     NOT NULL   DEFAULT '0',
+    `timestamp_created`  TEXT        NOT NULL   DEFAULT CURRENT_TIMESTAMP,
+    `timestamp_accessed` TEXT            NULL   DEFAULT NULL,
+
+    `quota_today`        INTEGER     NOT NULL   DEFAULT '0',
+    `quota_day`          TEXT            NULL   DEFAULT NULL,
+
+    `is_pro`             INTEGER     NOT NULL   DEFAULT 0,
+    `pro_token`          TEXT            NULL   DEFAULT NULL,
+
+    PRIMARY KEY (`user_id`)
+);
+
+CREATE TABLE `messages`
+(
+    `scn_message_id`     INTEGER                AUTO_INCREMENT,
+    `sender_user_id`     INTEGER     NOT NULL,
+
+    `timestamp_real`     TEXT        NOT NULL   DEFAULT CURRENT_TIMESTAMP,
+    `ack`                INTEGER     NOT NULL   DEFAULT 0,
+
+    `title`              TEXT        NOT NULL,
+    `content`            TEXT            NULL,
+    `priority`           INTEGER     NOT NULL,
+    `sendtime`           INTEGER     NOT NULL,
+
+    `fcm_message_id`     TEXT            NULL,
+    `usr_message_id`     TEXT            NULL,
+
+    PRIMARY KEY (`scn_message_id`)
+);
+
+CREATE TABLE `meta`
+(
+    `key`         TEXT     NOT NULL,
+    `value_int`   INTEGER      NULL,
+    `value_txt`   TEXT         NULL,
+
+    PRIMARY KEY (`key`)
+);
+
+INSERT INTO meta (key, value_int) VALUES ('schema', 2)

scnserver/db/impl/primary/schema/schema_3.ddl

@@ -0,0 +1,176 @@
+CREATE TABLE users
+(
+    user_id            INTEGER                             PRIMARY KEY AUTOINCREMENT,
+
+    username           TEXT                                    NULL  DEFAULT NULL,
+
+    send_key           TEXT                                NOT NULL,
+    read_key           TEXT                                NOT NULL,
+    admin_key          TEXT                                NOT NULL,
+
+    timestamp_created  INTEGER                             NOT NULL,
+    timestamp_lastread INTEGER                                 NULL   DEFAULT NULL,
+    timestamp_lastsent INTEGER                                 NULL   DEFAULT NULL,
+
+    messages_sent      INTEGER                             NOT NULL   DEFAULT '0',
+
+    quota_used         INTEGER                             NOT NULL   DEFAULT '0',
+    quota_used_day     TEXT                                    NULL   DEFAULT NULL,
+
+    is_pro             INTEGER   CHECK(is_pro IN (0, 1))   NOT NULL   DEFAULT 0,
+    pro_token          TEXT                                    NULL   DEFAULT NULL
+) STRICT;
+CREATE  UNIQUE INDEX "idx_users_protoken" ON users (pro_token) WHERE pro_token IS NOT NULL;
+
+
+CREATE TABLE clients
+(
+    client_id          INTEGER                                        PRIMARY KEY AUTOINCREMENT,
+
+    user_id            INTEGER                                        NOT NULL,
+    type               TEXT       CHECK(type IN ('ANDROID', 'IOS'))   NOT NULL,
+    fcm_token          TEXT                                               NULL,
+
+    timestamp_created  INTEGER                                        NOT NULL,
+
+    agent_model        TEXT                                           NOT NULL,
+    agent_version      TEXT                                           NOT NULL
+) STRICT;
+CREATE        INDEX "idx_clients_userid"   ON clients (user_id);
+CREATE UNIQUE INDEX "idx_clients_fcmtoken" ON clients (fcm_token);
+
+
+CREATE TABLE channels
+(
+    channel_id         INTEGER     PRIMARY KEY AUTOINCREMENT,
+
+    owner_user_id      INTEGER     NOT NULL,
+
+    internal_name      TEXT        NOT NULL,
+    display_name       TEXT        NOT NULL,
+
+    subscribe_key      TEXT        NOT NULL,
+    send_key           TEXT        NOT NULL,
+
+    timestamp_created  INTEGER     NOT NULL,
+    timestamp_lastsent INTEGER         NULL   DEFAULT NULL,
+
+    messages_sent      INTEGER     NOT NULL   DEFAULT '0'
+) STRICT;
+CREATE UNIQUE INDEX "idx_channels_identity" ON channels (owner_user_id, internal_name);
+
+CREATE TABLE subscriptions
+(
+    subscription_id        INTEGER                                PRIMARY KEY AUTOINCREMENT,
+
+    subscriber_user_id     INTEGER                                NOT NULL,
+    channel_owner_user_id  INTEGER                                NOT NULL,
+    channel_internal_name  TEXT                                   NOT NULL,
+    channel_id             INTEGER                                NOT NULL,
+
+    timestamp_created      INTEGER                                NOT NULL,
+
+    confirmed              INTEGER   CHECK(confirmed IN (0, 1))   NOT NULL
+) STRICT;
+CREATE UNIQUE INDEX "idx_subscriptions_ref"     ON subscriptions (subscriber_user_id, channel_owner_user_id, channel_internal_name);
+CREATE        INDEX "idx_subscriptions_chan"    ON subscriptions (channel_id);
+CREATE        INDEX "idx_subscriptions_subuser" ON subscriptions (subscriber_user_id);
+CREATE        INDEX "idx_subscriptions_ownuser" ON subscriptions (channel_owner_user_id);
+CREATE        INDEX "idx_subscriptions_tsc"     ON subscriptions (timestamp_created);
+CREATE        INDEX "idx_subscriptions_conf"    ON subscriptions (confirmed);
+
+
+CREATE TABLE messages
+(
+    scn_message_id        INTEGER                                  PRIMARY KEY AUTOINCREMENT,
+    sender_user_id        INTEGER                                  NOT NULL,
+    owner_user_id         INTEGER                                  NOT NULL,
+    channel_internal_name TEXT                                     NOT NULL,
+    channel_id            INTEGER                                  NOT NULL,
+    sender_ip             TEXT                                     NOT NULL,
+    sender_name           TEXT                                         NULL,
+
+    timestamp_real        INTEGER                                  NOT NULL,
+    timestamp_client      INTEGER                                      NULL,
+
+    title                 TEXT                                     NOT NULL,
+    content               TEXT                                         NULL,
+    priority              INTEGER  CHECK(priority IN (0, 1, 2))    NOT NULL,
+    usr_message_id        TEXT                                         NULL,
+
+    deleted               INTEGER  CHECK(deleted IN (0, 1))        NOT NULL    DEFAULT '0'
+) STRICT;
+CREATE        INDEX "idx_messages_owner_channel"    ON messages (owner_user_id, channel_internal_name COLLATE BINARY);
+CREATE        INDEX "idx_messages_owner_channel_nc" ON messages (owner_user_id, channel_internal_name COLLATE NOCASE);
+CREATE        INDEX "idx_messages_channel"          ON messages (channel_internal_name COLLATE BINARY);
+CREATE        INDEX "idx_messages_channel_nc"       ON messages (channel_internal_name COLLATE NOCASE);
+CREATE UNIQUE INDEX "idx_messages_idempotency"      ON messages (owner_user_id, usr_message_id COLLATE BINARY);
+CREATE        INDEX "idx_messages_senderip"         ON messages (sender_ip COLLATE BINARY);
+CREATE        INDEX "idx_messages_sendername"       ON messages (sender_name COLLATE BINARY);
+CREATE        INDEX "idx_messages_sendername_nc"    ON messages (sender_name COLLATE NOCASE);
+CREATE        INDEX "idx_messages_title"            ON messages (title COLLATE BINARY);
+CREATE        INDEX "idx_messages_title_nc"         ON messages (title COLLATE NOCASE);
+CREATE        INDEX "idx_messages_deleted"          ON messages (deleted);
+
+
+CREATE VIRTUAL TABLE messages_fts USING fts5
+(
+    channel_internal_name,
+    sender_name,
+    title,
+    content,
+
+    tokenize = unicode61,
+    content = 'messages',
+    content_rowid = 'scn_message_id'
+);
+
+CREATE TRIGGER fts_insert AFTER INSERT ON messages BEGIN
+    INSERT INTO messages_fts (rowid, channel_internal_name, sender_name, title, content) VALUES (new.scn_message_id, new.channel_internal_name, new.sender_name, new.title, new.content);
+END;
+
+CREATE TRIGGER fts_update AFTER UPDATE ON messages BEGIN
+    INSERT INTO messages_fts (messages_fts, rowid, channel_internal_name, sender_name, title, content) VALUES ('delete', old.scn_message_id, old.channel_internal_name, old.sender_name, old.title, old.content);
+    INSERT INTO messages_fts (              rowid, channel_internal_name, sender_name, title, content) VALUES (          new.scn_message_id, new.channel_internal_name, new.sender_name, new.title, new.content);
+END;
+
+CREATE TRIGGER fts_delete AFTER DELETE ON messages BEGIN
+    INSERT INTO messages_fts (messages_fts, rowid, channel_internal_name, sender_name, title, content) VALUES ('delete', old.scn_message_id, old.channel_internal_name, old.sender_name, old.title, old.content);
+END;
+
+
+
+CREATE TABLE deliveries
+(
+    delivery_id         INTEGER                                                  PRIMARY KEY AUTOINCREMENT,
+
+    scn_message_id      INTEGER                                                  NOT NULL,
+    receiver_user_id    INTEGER                                                  NOT NULL,
+    receiver_client_id  INTEGER                                                  NOT NULL,
+
+    timestamp_created   INTEGER                                                  NOT NULL,
+    timestamp_finalized INTEGER                                                      NULL,
+
+
+    status              TEXT     CHECK(status IN ('RETRY','SUCCESS','FAILED'))   NOT NULL,
+    retry_count         INTEGER                                                  NOT NULL   DEFAULT 0,
+    next_delivery       INTEGER                                                      NULL   DEFAULT NULL,
+
+    fcm_message_id      TEXT                                                         NULL
+) STRICT;
+CREATE INDEX "idx_deliveries_receiver" ON deliveries (scn_message_id, receiver_client_id);
+
+
+CREATE TABLE `meta`
+(
+    meta_key     TEXT       NOT NULL,
+    value_int    INTEGER        NULL,
+    value_txt    TEXT           NULL,
+    value_real   REAL           NULL,
+    value_blob   BLOB           NULL,
+
+    PRIMARY KEY (meta_key)
+) STRICT;
+
+
+INSERT INTO meta (meta_key, value_int) VALUES ('schema', 3)

scnserver/db/impl/primary/schema/schema_sqlite.ddl

@@ -0,0 +1,7 @@
+CREATE TABLE sqlite_master (
+    type text,
+    name text,
+    tbl_name text,
+    rootpage integer,
+    sql text
+);

scnserver/db/impl/primary/subscriptions.go

@@ -0,0 +1,190 @@
+package primary
+
+import (
+	"blackforestbytes.com/simplecloudnotifier/models"
+	"database/sql"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+	"time"
+)
+
+func (db *Database) CreateSubscription(ctx TxContext, subscriberUID models.UserID, channel models.Channel, confirmed bool) (models.Subscription, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.Subscription{}, err
+	}
+
+	now := time.Now().UTC()
+
+	res, err := tx.Exec(ctx, "INSERT INTO subscriptions (subscriber_user_id, channel_owner_user_id, channel_internal_name, channel_id, timestamp_created, confirmed) VALUES (:suid, :ouid, :cnam, :cid, :ts, :conf)", sq.PP{
+		"suid": subscriberUID,
+		"ouid": channel.OwnerUserID,
+		"cnam": channel.InternalName,
+		"cid":  channel.ChannelID,
+		"ts":   time2DB(now),
+		"conf": confirmed,
+	})
+	if err != nil {
+		return models.Subscription{}, err
+	}
+
+	liid, err := res.LastInsertId()
+	if err != nil {
+		return models.Subscription{}, err
+	}
+
+	return models.Subscription{
+		SubscriptionID:      models.SubscriptionID(liid),
+		SubscriberUserID:    subscriberUID,
+		ChannelOwnerUserID:  channel.OwnerUserID,
+		ChannelID:           channel.ChannelID,
+		ChannelInternalName: channel.InternalName,
+		TimestampCreated:    now,
+		Confirmed:           confirmed,
+	}, nil
+}
+
+func (db *Database) ListSubscriptionsByChannel(ctx TxContext, channelID models.ChannelID) ([]models.Subscription, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM subscriptions WHERE channel_id = :cid", sq.PP{"cid": channelID})
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := models.DecodeSubscriptions(rows)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func (db *Database) ListSubscriptionsByChannelOwner(ctx TxContext, ownerUserID models.UserID, confirmed *bool) ([]models.Subscription, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	cond := ""
+	if confirmed != nil && *confirmed {
+		cond = " AND confirmed = 1"
+	} else if confirmed != nil && !*confirmed {
+		cond = " AND confirmed = 0"
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM subscriptions WHERE channel_owner_user_id = :ouid"+cond, sq.PP{"ouid": ownerUserID})
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := models.DecodeSubscriptions(rows)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func (db *Database) ListSubscriptionsBySubscriber(ctx TxContext, subscriberUserID models.UserID, confirmed *bool) ([]models.Subscription, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	cond := ""
+	if confirmed != nil && *confirmed {
+		cond = " AND confirmed = 1"
+	} else if confirmed != nil && !*confirmed {
+		cond = " AND confirmed = 0"
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM subscriptions WHERE subscriber_user_id = :suid"+cond, sq.PP{"suid": subscriberUserID})
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := models.DecodeSubscriptions(rows)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func (db *Database) GetSubscription(ctx TxContext, subid models.SubscriptionID) (models.Subscription, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.Subscription{}, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM subscriptions WHERE subscription_id = :sid LIMIT 1", sq.PP{"sid": subid})
+	if err != nil {
+		return models.Subscription{}, err
+	}
+
+	sub, err := models.DecodeSubscription(rows)
+	if err != nil {
+		return models.Subscription{}, err
+	}
+
+	return sub, nil
+}
+
+func (db *Database) GetSubscriptionBySubscriber(ctx TxContext, subscriberId models.UserID, channelId models.ChannelID) (*models.Subscription, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM subscriptions WHERE subscriber_user_id = :suid AND channel_id = :cid LIMIT 1", sq.PP{
+		"suid": subscriberId,
+		"cid":  channelId,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	user, err := models.DecodeSubscription(rows)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &user, nil
+}
+
+func (db *Database) DeleteSubscription(ctx TxContext, subid models.SubscriptionID) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "DELETE FROM subscriptions WHERE subscription_id = :sid", sq.PP{"sid": subid})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) UpdateSubscriptionConfirmed(ctx TxContext, subscriptionID models.SubscriptionID, confirmed bool) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE subscriptions SET confirmed = :conf WHERE subscription_id = :sid", sq.PP{
+		"conf": confirmed,
+		"sid":  subscriptionID,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

scnserver/db/impl/primary/users.go

@@ -0,0 +1,251 @@
+package primary
+
+import (
+	scn "blackforestbytes.com/simplecloudnotifier"
+	"blackforestbytes.com/simplecloudnotifier/models"
+	"database/sql"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+	"time"
+)
+
+func (db *Database) CreateUser(ctx TxContext, readKey string, sendKey string, adminKey string, protoken *string, username *string) (models.User, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.User{}, err
+	}
+
+	now := time.Now().UTC()
+
+	res, err := tx.Exec(ctx, "INSERT INTO users (username, read_key, send_key, admin_key, is_pro, pro_token, timestamp_created) VALUES (:un, :rk, :sk, :ak, :pro, :tok, :ts)", sq.PP{
+		"un":  username,
+		"rk":  readKey,
+		"sk":  sendKey,
+		"ak":  adminKey,
+		"pro": bool2DB(protoken != nil),
+		"tok": protoken,
+		"ts":  time2DB(now),
+	})
+	if err != nil {
+		return models.User{}, err
+	}
+
+	liid, err := res.LastInsertId()
+	if err != nil {
+		return models.User{}, err
+	}
+
+	return models.User{
+		UserID:            models.UserID(liid),
+		Username:          username,
+		ReadKey:           readKey,
+		SendKey:           sendKey,
+		AdminKey:          adminKey,
+		TimestampCreated:  now,
+		TimestampLastRead: nil,
+		TimestampLastSent: nil,
+		MessagesSent:      0,
+		QuotaUsed:         0,
+		QuotaUsedDay:      nil,
+		IsPro:             protoken != nil,
+		ProToken:          protoken,
+	}, nil
+}
+
+func (db *Database) ClearProTokens(ctx TxContext, protoken string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE users SET is_pro=0, pro_token=NULL WHERE pro_token = :tok", sq.PP{"tok": protoken})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) GetUserByKey(ctx TxContext, key string) (*models.User, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return nil, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM users WHERE admin_key = :key OR send_key = :key OR read_key = :key LIMIT 1", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+
+	user, err := models.DecodeUser(rows)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &user, nil
+}
+
+func (db *Database) GetUser(ctx TxContext, userid models.UserID) (models.User, error) {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return models.User{}, err
+	}
+
+	rows, err := tx.Query(ctx, "SELECT * FROM users WHERE user_id = :uid LIMIT 1", sq.PP{"uid": userid})
+	if err != nil {
+		return models.User{}, err
+	}
+
+	user, err := models.DecodeUser(rows)
+	if err != nil {
+		return models.User{}, err
+	}
+
+	return user, nil
+}
+
+func (db *Database) UpdateUserUsername(ctx TxContext, userid models.UserID, username *string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE users SET username = :nam WHERE user_id = :uid", sq.PP{
+		"nam": username,
+		"uid": userid,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) UpdateUserProToken(ctx TxContext, userid models.UserID, protoken *string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE users SET pro_token = :tok, is_pro = :pro WHERE user_id = :uid", sq.PP{
+		"tok": protoken,
+		"pro": bool2DB(protoken != nil),
+		"uid": userid,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) IncUserMessageCounter(ctx TxContext, user models.User) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	quota := user.QuotaUsedToday() + 1
+
+	_, err = tx.Exec(ctx, "UPDATE users SET timestamp_lastsent = :ts, messages_sent = :ctr, quota_used = :qu, quota_used_day = :qd WHERE user_id = :uid", sq.PP{
+		"ts":  time2DB(time.Now()),
+		"ctr": user.MessagesSent + 1,
+		"qu":  quota,
+		"qd":  scn.QuotaDayString(),
+		"uid": user.UserID,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) UpdateUserLastRead(ctx TxContext, userid models.UserID) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE users SET timestamp_lastread = :ts WHERE user_id = :uid", sq.PP{
+		"ts":  time2DB(time.Now()),
+		"uid": userid,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) UpdateUserKeys(ctx TxContext, userid models.UserID, sendKey string, readKey string, adminKey string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE users SET send_key = :sk, read_key = :rk, admin_key = :ak WHERE user_id = :uid", sq.PP{
+		"sk":  sendKey,
+		"rk":  readKey,
+		"ak":  adminKey,
+		"uid": userid,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) UpdateUserSendKey(ctx TxContext, userid models.UserID, newkey string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE users SET send_key = :sk WHERE user_id = :uid", sq.PP{
+		"sk":  newkey,
+		"uid": userid,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) UpdateUserReadKey(ctx TxContext, userid models.UserID, newkey string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE users SET read_key = :rk WHERE user_id = :uid", sq.PP{
+		"rk":  newkey,
+		"uid": userid,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Database) UpdateUserAdminKey(ctx TxContext, userid models.UserID, newkey string) error {
+	tx, err := ctx.GetOrCreateTransaction(db)
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(ctx, "UPDATE users SET admin_key = :ak WHERE user_id = :uid", sq.PP{
+		"ak":  newkey,
+		"uid": userid,
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

scnserver/db/impl/primary/utils.go

@@ -0,0 +1,25 @@
+package primary
+
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"time"
+)
+
+func bool2DB(b bool) int {
+	if b {
+		return 1
+	} else {
+		return 0
+	}
+}
+
+func time2DB(t time.Time) int64 {
+	return t.UnixMilli()
+}
+
+func time2DBOpt(t *time.Time) *int64 {
+	if t == nil {
+		return nil
+	}
+	return langext.Ptr(t.UnixMilli())
+}

scnserver/db/impl/requests/database.go

@@ -0,0 +1,111 @@
+package requests
+
+import (
+	server "blackforestbytes.com/simplecloudnotifier"
+	"blackforestbytes.com/simplecloudnotifier/db/dbtools"
+	"blackforestbytes.com/simplecloudnotifier/db/impl/requests/schema"
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"github.com/jmoiron/sqlx"
+	_ "github.com/mattn/go-sqlite3"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+	"time"
+)
+
+type Database struct {
+	db  sq.DB
+	pp  *dbtools.DBPreprocessor
+	wal bool
+}
+
+func NewRequestsDatabase(cfg server.Config) (*Database, error) {
+	conf := cfg.DBRequests
+
+	url := fmt.Sprintf("file:%s?_journal=%s&_timeout=%d&_fk=%s", conf.File, conf.Journal, conf.Timeout.Milliseconds(), langext.FormatBool(conf.CheckForeignKeys, "true", "false"))
+
+	xdb, err := sqlx.Open("sqlite3", url)
+	if err != nil {
+		return nil, err
+	}
+
+	if conf.SingleConn {
+		xdb.SetMaxOpenConns(1)
+	} else {
+		xdb.SetMaxOpenConns(5)
+		xdb.SetMaxIdleConns(5)
+		xdb.SetConnMaxLifetime(60 * time.Minute)
+		xdb.SetConnMaxIdleTime(60 * time.Minute)
+	}
+
+	qqdb := sq.NewDB(xdb)
+
+	qqdb.AddListener(dbtools.DBLogger{})
+
+	pp, err := dbtools.NewDBPreprocessor(qqdb)
+	if err != nil {
+		return nil, err
+	}
+
+	qqdb.AddListener(pp)
+
+	scndb := &Database{db: qqdb, pp: pp, wal: conf.Journal == "WAL"}
+
+	return scndb, nil
+}
+
+func (db *Database) Migrate(ctx context.Context) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 24*time.Second)
+	defer cancel()
+
+	currschema, err := db.ReadSchema(ctx)
+	if currschema == 0 {
+
+		_, err = db.db.Exec(ctx, schema.RequestsSchema1, sq.PP{})
+		if err != nil {
+			return err
+		}
+
+		err = db.WriteMetaInt(ctx, "schema", 1)
+		if err != nil {
+			return err
+		}
+
+		err = db.pp.Init(ctx)
+		if err != nil {
+			return err
+		}
+
+		return nil
+
+	} else if currschema == 1 {
+		return nil // current
+	} else {
+		return errors.New(fmt.Sprintf("Unknown DB schema: %d", currschema))
+	}
+
+}
+
+func (db *Database) Ping(ctx context.Context) error {
+	return db.db.Ping(ctx)
+}
+
+func (db *Database) BeginTx(ctx context.Context) (sq.Tx, error) {
+	return db.db.BeginTransaction(ctx, sql.LevelDefault)
+}
+
+func (db *Database) Stop(ctx context.Context) error {
+	if db.wal {
+		_, err := db.db.Exec(ctx, "PRAGMA wal_checkpoint;", sq.PP{})
+		if err != nil {
+			return err
+		}
+	}
+	err := db.db.Exit()
+	if err != nil {
+		return err
+	}
+	return nil
+}

scnserver/db/impl/requests/meta.go

@@ -0,0 +1,242 @@
+package requests
+
+import (
+	"context"
+	"errors"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/sq"
+)
+
+func (db *Database) ReadSchema(ctx context.Context) (retval int, reterr error) {
+
+	r1, err := db.db.Query(ctx, "SELECT name FROM sqlite_master WHERE type = :typ AND name = :name", sq.PP{"typ": "table", "name": "meta"})
+	if err != nil {
+		return 0, err
+	}
+	defer func() {
+		err = r1.Close()
+		if err != nil {
+			// overwrite return values
+			retval = 0
+			reterr = err
+		}
+	}()
+
+	if !r1.Next() {
+		return 0, nil
+	}
+
+	err = r1.Close()
+	if err != nil {
+		return 0, err
+	}
+
+	r2, err := db.db.Query(ctx, "SELECT value_int FROM meta WHERE meta_key = :key", sq.PP{"key": "schema"})
+	if err != nil {
+		return 0, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = 0
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return 0, errors.New("no schema entry in meta table")
+	}
+
+	var dbschema int
+	err = r2.Scan(&dbschema)
+	if err != nil {
+		return 0, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return 0, err
+	}
+
+	return dbschema, nil
+}
+
+func (db *Database) WriteMetaString(ctx context.Context, key string, value string) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_txt) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_txt = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) WriteMetaInt(ctx context.Context, key string, value int64) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_int) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_int = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) WriteMetaReal(ctx context.Context, key string, value float64) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_real) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_real = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) WriteMetaBlob(ctx context.Context, key string, value []byte) error {
+	_, err := db.db.Exec(ctx, "INSERT INTO meta (meta_key, value_blob) VALUES (:key, :val) ON CONFLICT(meta_key) DO UPDATE SET value_blob = :val", sq.PP{
+		"key": key,
+		"val": value,
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *Database) ReadMetaString(ctx context.Context, key string) (retval *string, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_txt FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value string
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) ReadMetaInt(ctx context.Context, key string) (retval *int64, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_int FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value int64
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) ReadMetaReal(ctx context.Context, key string) (retval *float64, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_real FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value float64
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) ReadMetaBlob(ctx context.Context, key string) (retval *[]byte, reterr error) {
+	r2, err := db.db.Query(ctx, "SELECT value_blob FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		err = r2.Close()
+		if err != nil {
+			// overwrite return values
+			retval = nil
+			reterr = err
+		}
+	}()
+
+	if !r2.Next() {
+		return nil, errors.New("no matching entry in meta table")
+	}
+
+	var value []byte
+	err = r2.Scan(&value)
+	if err != nil {
+		return nil, err
+	}
+
+	err = r2.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	return langext.Ptr(value), nil
+}
+
+func (db *Database) DeleteMeta(ctx context.Context, key string) error {
+	_, err := db.db.Exec(ctx, "DELETE FROM meta WHERE meta_key = :key", sq.PP{"key": key})
+	if err != nil {
+		return err
+	}
+	return nil
+}

scnserver/db/impl/requests/schema/assets.go

@@ -0,0 +1,6 @@
+package schema
+
+import _ "embed"
+
+//go:embed schema_1.ddl
+var RequestsSchema1 string

scnserver/db/impl/requests/schema/schema_1.ddl

@@ -0,0 +1,22 @@
+
+CREATE TABLE `requests`
+(
+    request_id           INTEGER        PRIMARY KEY,
+    timestamp_created    INTEGER        NOT NULL
+
+) STRICT;
+
+
+CREATE TABLE `meta`
+(
+    meta_key     TEXT       NOT NULL,
+    value_int    INTEGER        NULL,
+    value_txt    TEXT           NULL,
+    value_real   REAL           NULL,
+    value_blob   BLOB           NULL,
+
+    PRIMARY KEY (meta_key)
+) STRICT;
+
+
+INSERT INTO meta (meta_key, value_int) VALUES ('schema', 1)

scnserver/db/impl/requests/schema/schema_sqlite.ddl

@@ -0,0 +1,7 @@
+CREATE TABLE sqlite_master (
+    type text,
+    name text,
+    tbl_name text,
+    rootpage integer,
+    sql text
+);

scnserver/db/impl/requests/utils.go

@@ -0,0 +1,25 @@
+package requests
+
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"time"
+)
+
+func bool2DB(b bool) int {
+	if b {
+		return 1
+	} else {
+		return 0
+	}
+}
+
+func time2DB(t time.Time) int64 {
+	return t.UnixMilli()
+}
+
+func time2DBOpt(t *time.Time) *int64 {
+	if t == nil {
+		return nil
+	}
+	return langext.Ptr(t.UnixMilli())
+}