Files
mtusi2026lab2/database.go
T

181 lines
5.5 KiB
Go

package main
import (
"context"
"crypto/sha256"
"database/sql"
"embed"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"time"
"github.com/lib/pq"
"github.com/redis/go-redis/v9"
"mtusi2026lab2/models"
)
//go:embed migrations/*.sql
var migrations embed.FS
type store struct {
db *sql.DB
cache *redis.Client
metrics *cacheMetrics
}
// A transaction-scoped advisory lock serializes migrations across starting API processes.
func migrate(ctx context.Context, db *sql.DB) error {
tx, err := db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if _, err = tx.ExecContext(ctx, `SELECT pg_advisory_xact_lock(202602)`); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations (name text PRIMARY KEY, checksum text NOT NULL, applied_at timestamptz NOT NULL DEFAULT clock_timestamp())`); err != nil {
return err
}
entries, err := migrations.ReadDir("migrations")
if err != nil {
return err
}
for _, entry := range entries {
data, err := migrations.ReadFile("migrations/" + entry.Name())
if err != nil {
return err
}
sum := sha256.Sum256(data)
checksum := hex.EncodeToString(sum[:])
var previous string
err = tx.QueryRowContext(ctx, `SELECT checksum FROM schema_migrations WHERE name=$1`, entry.Name()).Scan(&previous)
if err == nil {
if previous != checksum {
return fmt.Errorf("changed migration %s", entry.Name())
}
continue
}
if !errors.Is(err, sql.ErrNoRows) {
return err
}
if _, err = tx.ExecContext(ctx, string(data)); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO schema_migrations(name,checksum) VALUES($1,$2)`, entry.Name(), checksum); err != nil {
return err
}
}
return tx.Commit()
}
func scanUser(row interface{ Scan(...any) error }) (models.User, error) {
var u models.User
err := row.Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
u.CreatedAt = u.CreatedAt.UTC()
return u, err
}
func (s *store) user(ctx context.Context, id models.UUID) (models.User, error) {
key := "profile:v1:" + string(id)
if s.cache != nil {
cacheCtx, cancel := context.WithTimeout(ctx, 150*time.Millisecond)
data, err := s.cache.Get(cacheCtx, key).Bytes()
cancel()
var u models.User
if err == nil && json.Unmarshal(data, &u) == nil && u.ID == id {
s.metrics.hits.Add(1)
return u, nil
}
s.metrics.misses.Add(1)
if err != nil && !errors.Is(err, redis.Nil) {
s.metrics.failures.Add(1)
}
}
u, err := scanUser(s.db.QueryRowContext(ctx, `SELECT id,username,display_name,created_at FROM users WHERE id=$1`, id))
if err == nil && s.cache != nil {
data, _ := json.Marshal(u)
cacheCtx, cancel := context.WithTimeout(ctx, 150*time.Millisecond)
if s.cache.Set(cacheCtx, key, data, 5*time.Minute).Err() != nil {
s.metrics.failures.Add(1)
}
cancel()
}
return u, err
}
func (s *store) createChat(ctx context.Context, title string, members []models.UUID) (models.Chat, error) {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return models.Chat{}, err
}
defer tx.Rollback()
chat := models.Chat{ID: models.UUID(newID()), Title: title, MemberIDs: members}
err = tx.QueryRowContext(ctx, `INSERT INTO chats(id,title) VALUES($1,$2) RETURNING created_at`, chat.ID, title).Scan(&chat.CreatedAt)
if err != nil {
return chat, err
}
for i, id := range members {
if _, err = tx.ExecContext(ctx, `INSERT INTO chat_members(chat_id,user_id,position) VALUES($1,$2,$3)`, chat.ID, id, i); err != nil {
return chat, err
}
}
err = tx.Commit()
chat.CreatedAt = chat.CreatedAt.UTC()
return chat, err
}
func scanChat(row interface{ Scan(...any) error }) (models.Chat, error) {
var c models.Chat
var members pq.StringArray
err := row.Scan(&c.ID, &c.Title, &c.CreatedAt, &members)
c.CreatedAt = c.CreatedAt.UTC()
c.MemberIDs = make([]models.UUID, len(members))
for i, m := range members {
c.MemberIDs[i] = models.UUID(m)
}
return c, err
}
const chatColumns = `c.id,c.title,c.created_at,ARRAY(SELECT user_id::text FROM chat_members WHERE chat_id=c.id ORDER BY position)`
func (s *store) chat(ctx context.Context, id, user models.UUID) (models.Chat, error) {
return scanChat(s.db.QueryRowContext(ctx, `SELECT `+chatColumns+` FROM chats c WHERE c.id=$1 AND EXISTS(SELECT 1 FROM chat_members WHERE chat_id=c.id AND user_id=$2)`, id, user))
}
func (s *store) chats(ctx context.Context, user models.UUID, p cursor, limit int) ([]models.Chat, error) {
rows, err := s.db.QueryContext(ctx, `SELECT `+chatColumns+` FROM chats c WHERE EXISTS(SELECT 1 FROM chat_members WHERE chat_id=c.id AND user_id=$1) AND (c.created_at,c.id)>($2,$3::uuid) ORDER BY c.created_at,c.id LIMIT $4`, user, p.CreatedAt, p.ID, limit+1)
if err != nil {
return nil, err
}
defer rows.Close()
items := []models.Chat{}
for rows.Next() {
c, err := scanChat(rows)
if err != nil {
return nil, err
}
items = append(items, c)
}
return items, rows.Err()
}
func (s *store) messages(ctx context.Context, chat models.UUID, p cursor, limit int) ([]models.Message, error) {
rows, err := s.db.QueryContext(ctx, `SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=$1 AND (created_at,id)>($2,$3::uuid) ORDER BY created_at,id LIMIT $4`, chat, p.CreatedAt, p.ID, limit+1)
if err != nil {
return nil, err
}
defer rows.Close()
items := []models.Message{}
for rows.Next() {
var m models.Message
if err = rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
return nil, err
}
m.CreatedAt = m.CreatedAt.UTC()
items = append(items, m)
}
return items, rows.Err()
}