mirrors/gotosocial
1
0
Fork 0
mirror of https://github.com/superseriousbusiness/gotosocial.git synced 2026-01-05 21:43:16 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

improvements to caching for lists and relationship to accounts / follows

Browse source
This commit is contained in:
kim 2024-09-11 22:38:35 +01:00
commit 002bd86a39
27 changed files with 1002 additions and 1333 deletions
Download patch file Download diff file Expand all files Collapse all files

475
internal/db/bundb/list.go
View file

@ -29,6 +29,7 @@ import (
"github.com/superseriousbusiness/gotosocial/internal/gtserror"
"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
"github.com/superseriousbusiness/gotosocial/internal/log"
"github.com/superseriousbusiness/gotosocial/internal/paging"
"github.com/superseriousbusiness/gotosocial/internal/state"
"github.com/superseriousbusiness/gotosocial/internal/util"
"github.com/uptrace/bun"
@ -85,39 +86,52 @@ func (l *listDB) getList(ctx context.Context, lookup string, dbQuery func(*gtsmo
return list, nil
}
func (l *listDB) GetListsForAccountID(ctx context.Context, accountID string) ([]*gtsmodel.List, error) {
// Fetch IDs of all lists owned by this account.
var listIDs []string
if err := l.db.
NewSelect().
TableExpr("? AS ?", bun.Ident("lists"), bun.Ident("list")).
Column("list.id").
Where("? = ?", bun.Ident("list.account_id"), accountID).
Order("list.id DESC").
Scan(ctx, &listIDs); err != nil {
func (l *listDB) GetListsByAccountID(ctx context.Context, accountID string) ([]*gtsmodel.List, error) {
listIDs, err := l.getListIDsByAccountID(ctx, accountID)
if err != nil {
return nil, err
}
if len(listIDs) == 0 {
return nil, nil
}
// Return lists by their IDs.
return l.GetListsByIDs(ctx, listIDs)
}
func (l *listDB) CountListsForAccountID(ctx context.Context, accountID string) (int, error) {
return l.db.
NewSelect().
Table("lists").
Where("? = ?", bun.Ident("account_id"), accountID).
Count(ctx)
func (l *listDB) CountListsByAccountID(ctx context.Context, accountID string) (int, error) {
listIDs, err := l.getListIDsByAccountID(ctx, accountID)
return len(listIDs), err
}
func (l *listDB) GetListsWithFollowID(ctx context.Context, followID string) ([]*gtsmodel.List, error) {
listIDs, err := l.getListIDsWithFollowID(ctx, followID)
if err != nil {
return nil, err
}
return l.GetListsByIDs(ctx, listIDs)
}
func (l *listDB) GetFollowsInList(ctx context.Context, listID string, page *paging.Page) ([]*gtsmodel.Follow, error) {
followIDs, err := l.GetFollowIDsInList(ctx, listID, page)
if err != nil {
return nil, err
}
return l.state.DB.GetFollowsByIDs(ctx, followIDs)
}
func (l *listDB) GetAccountsInList(ctx context.Context, listID string, page *paging.Page) ([]*gtsmodel.Account, error) {
accountIDs, err := l.GetAccountIDsInList(ctx, listID, page)
if err != nil {
return nil, err
}
return l.state.DB.GetAccountsByIDs(ctx, accountIDs)
}
func (l *listDB) IsAccountInListID(ctx context.Context, listID string, accountID string) (bool, error) {
accountIDs, err := l.GetAccountIDsInList(ctx, listID, nil)
return slices.Contains(accountIDs, accountID), err
}
func (l *listDB) PopulateList(ctx context.Context, list *gtsmodel.List) error {
var (
err error
errs = gtserror.NewMultiError(2)
errs gtserror.MultiError
)
if list.Account == nil {
@ -131,18 +145,6 @@ func (l *listDB) PopulateList(ctx context.Context, list *gtsmodel.List) error {
}
}
if list.ListEntries == nil {
// List entries are not set, fetch from the database.
list.ListEntries, err = l.state.DB.GetListEntries(
gtscontext.SetBarebones(ctx),
list.ID,
"", "", "", 0,
)
if err != nil {
errs.Appendf("error populating list entries: %w", err)
}
}
return errs.Combine()
}
@ -161,9 +163,6 @@ func (l *listDB) UpdateList(ctx context.Context, list *gtsmodel.List, columns ..
}
defer func() {
// Invalidate all entries for this list ID.
l.state.Caches.DB.ListEntry.Invalidate("ListID", list.ID)
// Invalidate this entire list's timeline.
if err := l.state.Timelines.List.RemoveTimeline(ctx, list.ID); err != nil {
log.Errorf(ctx, "error invalidating list timeline: %q", err)
@ -181,21 +180,6 @@ func (l *listDB) UpdateList(ctx context.Context, list *gtsmodel.List, columns ..
}
func (l *listDB) DeleteListByID(ctx context.Context, id string) error {
// Load list by ID into cache to ensure we can perform
// all necessary cache invalidation hooks on removal.
_, err := l.GetListByID(
// Don't populate the entry;
// we only want the list ID.
gtscontext.SetBarebones(ctx),
id,
)
if err != nil && !errors.Is(err, db.ErrNoEntries) {
// NOTE: even if db.ErrNoEntries is returned, we
// still run the below transaction to ensure related
// objects are appropriately deleted.
return err
}
defer func() {
// Invalidate this list from cache.
l.state.Caches.DB.List.Invalidate("ID", id)
@ -224,128 +208,82 @@ func (l *listDB) DeleteListByID(ctx context.Context, id string) error {
})
}
/*
LIST ENTRY functions
*/
func (l *listDB) getListIDsByAccountID(ctx context.Context, accountID string) ([]string, error) {
return l.state.Caches.DB.ListIDs.Load("a"+accountID, func() ([]string, error) {
var listIDs []string
func (l *listDB) GetListEntryByID(ctx context.Context, id string) (*gtsmodel.ListEntry, error) {
return l.getListEntry(
ctx,
"ID",
func(listEntry *gtsmodel.ListEntry) error {
return l.db.NewSelect().
Model(listEntry).
Where("? = ?", bun.Ident("list_entry.id"), id).
Scan(ctx)
},
id,
)
}
func (l *listDB) getListEntry(ctx context.Context, lookup string, dbQuery func(*gtsmodel.ListEntry) error, keyParts ...any) (*gtsmodel.ListEntry, error) {
listEntry, err := l.state.Caches.DB.ListEntry.LoadOne(lookup, func() (*gtsmodel.ListEntry, error) {
var listEntry gtsmodel.ListEntry
// Not cached! Perform database query.
if err := dbQuery(&listEntry); err != nil {
// List IDs not in cache.
// Perform the DB query.
if _, err := l.db.NewSelect().
Table("lists").
Column("id").
Where("? = ?", bun.Ident("account_id"), accountID).
Exec(ctx, &listIDs); err != nil &&
!errors.Is(err, db.ErrNoEntries) {
return nil, err
}
return &listEntry, nil
}, keyParts...)
if err != nil {
return nil, err // already processed
}
if gtscontext.Barebones(ctx) {
// Only a barebones model was requested.
return listEntry, nil
}
// Further populate the list entry fields where applicable.
if err := l.state.DB.PopulateListEntry(ctx, listEntry); err != nil {
return nil, err
}
return listEntry, nil
return listIDs, nil
})
}
func (l *listDB) GetListEntries(ctx context.Context,
listID string,
maxID string,
sinceID string,
minID string,
limit int,
) ([]*gtsmodel.ListEntry, error) {
// Ensure reasonable
if limit < 0 {
limit = 0
}
func (l *listDB) getListIDsWithFollowID(ctx context.Context, followID string) ([]string, error) {
return l.state.Caches.DB.ListIDs.Load("f"+followID, func() ([]string, error) {
var listIDs []string
// Make educated guess for slice size
var (
entryIDs = make([]string, 0, limit)
frontToBack = true
)
q := l.db.
NewSelect().
TableExpr("? AS ?", bun.Ident("list_entries"), bun.Ident("entry")).
// Select only IDs from table
Column("entry.id").
// Select only entries belonging to listID.
Where("? = ?", bun.Ident("entry.list_id"), listID)
if maxID != "" {
// return only entries LOWER (ie., older) than maxID
q = q.Where("? < ?", bun.Ident("entry.id"), maxID)
}
if sinceID != "" {
// return only entries HIGHER (ie., newer) than sinceID
q = q.Where("? > ?", bun.Ident("entry.id"), sinceID)
}
if minID != "" {
// return only entries HIGHER (ie., newer) than minID
q = q.Where("? > ?", bun.Ident("entry.id"), minID)
// page up
frontToBack = false
}
if limit > 0 {
// limit amount of entries returned
q = q.Limit(limit)
}
if frontToBack {
// Page down.
q = q.Order("entry.id DESC")
} else {
// Page up.
q = q.Order("entry.id ASC")
}
if err := q.Scan(ctx, &entryIDs); err != nil {
return nil, err
}
if len(entryIDs) == 0 {
return nil, nil
}
// If we're paging up, we still want entries
// to be sorted by ID desc, so reverse ids slice.
// https://zchee.github.io/golang-wiki/SliceTricks/#reversing
if !frontToBack {
for l, r := 0, len(entryIDs)-1; l < r; l, r = l+1, r-1 {
entryIDs[l], entryIDs[r] = entryIDs[r], entryIDs[l]
// List IDs not in cache.
// Perform the DB query.
if _, err := l.db.NewSelect().
Table("list_entries").
Column("list_id").
Where("? = ?", bun.Ident("follow_id"), followID).
Exec(ctx, &listIDs); err != nil &&
!errors.Is(err, db.ErrNoEntries) {
return nil, err
}
}
// Return list entries by their IDs.
return l.GetListEntriesByIDs(ctx, entryIDs)
return listIDs, nil
})
}
func (l *listDB) GetFollowIDsInList(ctx context.Context, listID string, page *paging.Page) ([]string, error) {
return loadPagedIDs(&l.state.Caches.DB.ListedIDs, "f"+listID, page, func() ([]string, error) {
var followIDs []string
// Follow IDs not in cache.
// Perform the DB query.
_, err := l.db.NewSelect().
Table("list_entries").
Column("follow_id").
Where("? = ?", bun.Ident("list_id"), listID).
Exec(ctx, &followIDs)
if err != nil && !errors.Is(err, db.ErrNoEntries) {
return nil, err
}
return followIDs, nil
})
}
func (l *listDB) GetAccountIDsInList(ctx context.Context, listID string, page *paging.Page) ([]string, error) {
return loadPagedIDs(&l.state.Caches.DB.ListedIDs, "a"+listID, page, func() ([]string, error) {
var accountIDs []string
// Account IDs not in cache.
// Perform the DB query.
_, err := l.db.NewSelect().
Table("follows").
Column("follows.target_account_id").
Join("INNER JOIN ?", bun.Ident("list_entries")).
JoinOn("? = ?", bun.Ident("follows.id"), bun.Ident("list_entries.follow_id")).
Where("? = ?", bun.Ident("list_entries.list_id"), listID).
Exec(ctx, &accountIDs)
if err != nil && !errors.Is(err, db.ErrNoEntries) {
return nil, err
}
return accountIDs, nil
})
}
func (l *listDB) GetListsByIDs(ctx context.Context, ids []string) ([]*gtsmodel.List, error) {
@ -402,82 +340,6 @@ func (l *listDB) GetListsByIDs(ctx context.Context, ids []string) ([]*gtsmodel.L
return lists, nil
}
func (l *listDB) GetListEntriesByIDs(ctx context.Context, ids []string) ([]*gtsmodel.ListEntry, error) {
// Load all entry IDs via cache loader callbacks.
entries, err := l.state.Caches.DB.ListEntry.LoadIDs("ID",
ids,
func(uncached []string) ([]*gtsmodel.ListEntry, error) {
// Avoid querying
// if none uncached.
count := len(uncached)
if count == 0 {
return nil, nil
}
// Preallocate expected length of uncached entries.
entries := make([]*gtsmodel.ListEntry, 0, count)
// Perform database query scanning
// the remaining (uncached) IDs.
if err := l.db.NewSelect().
Model(&entries).
Where("? IN (?)", bun.Ident("id"), bun.In(uncached)).
Scan(ctx); err != nil {
return nil, err
}
return entries, nil
},
)
if err != nil {
return nil, err
}
// Reorder the entries by their
// IDs to ensure in correct order.
getID := func(e *gtsmodel.ListEntry) string { return e.ID }
util.OrderBy(entries, ids, getID)
if gtscontext.Barebones(ctx) {
// no need to fully populate.
return entries, nil
}
// Populate all loaded entries, removing those we fail to
// populate (removes needing so many nil checks everywhere).
entries = slices.DeleteFunc(entries, func(entry *gtsmodel.ListEntry) bool {
if err := l.PopulateListEntry(ctx, entry); err != nil {
log.Errorf(ctx, "error populating entry %s: %v", entry.ID, err)
return true
}
return false
})
return entries, nil
}
func (l *listDB) GetListEntriesForFollowID(ctx context.Context, followID string) ([]*gtsmodel.ListEntry, error) {
var entryIDs []string
if err := l.db.
NewSelect().
TableExpr("? AS ?", bun.Ident("list_entries"), bun.Ident("entry")).
// Select only IDs from table
Column("entry.id").
// Select only entries belonging with given followID.
Where("? = ?", bun.Ident("entry.follow_id"), followID).
Scan(ctx, &entryIDs); err != nil {
return nil, err
}
if len(entryIDs) == 0 {
return nil, nil
}
// Return list entries by their IDs.
return l.GetListEntriesByIDs(ctx, entryIDs)
}
func (l *listDB) PopulateListEntry(ctx context.Context, listEntry *gtsmodel.ListEntry) error {
var err error
@ -513,14 +375,10 @@ func (l *listDB) PutListEntries(ctx context.Context, entries []*gtsmodel.ListEnt
// Finally, insert each list entry into the database.
return l.db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
for _, entry := range entries {
entry := entry // rescope
if err := l.state.Caches.DB.ListEntry.Store(entry, func() error {
_, err := tx.
NewInsert().
Model(entry).
Exec(ctx)
return err
}); err != nil {
if _, err := tx.
NewInsert().
Model(entry).
Exec(ctx); err != nil {
return err
}
}
@ -528,77 +386,70 @@ func (l *listDB) PutListEntries(ctx context.Context, entries []*gtsmodel.ListEnt
})
}
func (l *listDB) DeleteListEntry(ctx context.Context, id string) error {
// Load list entry into cache to ensure we can perform
// all necessary cache invalidation hooks on removal.
entry, err := l.GetListEntryByID(
// Don't populate the entry;
// we only want the list ID.
gtscontext.SetBarebones(ctx),
id,
)
if err != nil {
if errors.Is(err, db.ErrNoEntries) {
// Already gone.
return nil
}
return err
}
defer func() {
// Invalidate this list entry upon delete.
l.state.Caches.DB.ListEntry.Invalidate("ID", id)
// Invalidate the timeline for the list this entry belongs to.
if err := l.state.Timelines.List.RemoveTimeline(ctx, entry.ListID); err != nil {
log.Errorf(ctx, "error invalidating list timeline: %q", err)
}
}()
// Finally delete the list entry.
_, err = l.db.NewDelete().
func (l *listDB) DeleteListEntry(ctx context.Context, listID string, followID string) error {
// Delete list entry with given
// ID, returning its list ID.
if _, err := l.db.NewDelete().
Table("list_entries").
Where("? = ?", bun.Ident("id"), id).
Exec(ctx)
return err
}
func (l *listDB) DeleteListEntriesForFollowID(ctx context.Context, followID string) error {
var entryIDs []string
// Fetch entry IDs for follow ID.
if err := l.db.
NewSelect().
Table("list_entries").
Column("id").
Where("? = ?", bun.Ident("list_id"), listID).
Where("? = ?", bun.Ident("follow_id"), followID).
Order("id DESC").
Scan(ctx, &entryIDs); err != nil {
Exec(ctx, &listID); err != nil &&
!errors.Is(err, db.ErrNoEntries) {
return err
}
for _, id := range entryIDs {
// Delete each separately to trigger cache invalidations.
if err := l.DeleteListEntry(ctx, id); err != nil {
return err
}
// Invalidate list IDs containing follow.
l.state.Caches.DB.ListIDs.Invalidate(
"f" + followID,
)
// Invalidate account / follow IDs in list.
l.state.Caches.DB.ListedIDs.Invalidate(
"a"+listID,
"f"+listID,
)
// Invalidate the timeline for the list this entry belongs to.
if err := l.state.Timelines.List.RemoveTimeline(ctx, listID); err != nil {
log.Errorf(ctx, "error invalidating list timeline: %q", err)
}
return nil
}
func (l *listDB) ListIncludesAccount(ctx context.Context, listID string, accountID string) (bool, error) {
exists, err := l.db.
NewSelect().
TableExpr("? AS ?", bun.Ident("list_entries"), bun.Ident("list_entry")).
Join(
"JOIN ? AS ? ON ? = ?",
bun.Ident("follows"), bun.Ident("follow"),
bun.Ident("list_entry.follow_id"), bun.Ident("follow.id"),
).
Where("? = ?", bun.Ident("list_entry.list_id"), listID).
Where("? = ?", bun.Ident("follow.target_account_id"), accountID).
Exists(ctx)
func (l *listDB) DeleteListEntriesTargettingFollowID(ctx context.Context, followID string) error {
var listIDs []string
return exists, err
// Delete all entries with follow
// ID, returning IDs and list IDs.
if _, err := l.db.NewDelete().
Table("list_entries").
Where("? = ?", bun.Ident("follow_id"), followID).
Returning("?", bun.Ident("list_id")).
Exec(ctx, &listIDs); err != nil &&
!errors.Is(err, db.ErrNoEntries) {
return err
}
// Invalidate list IDs containing follow.
l.state.Caches.DB.ListIDs.Invalidate(
"f" + followID,
)
// Iterate through list IDs of deleted entries.
for _, listID := range util.Deduplicate(listIDs) {
// Invalidate account / follow IDs in list.
l.state.Caches.DB.ListedIDs.Invalidate(
"a"+listID,
"f"+listID,
)
// Invalidate the timeline for the list this entry belongs to.
if err := l.state.Timelines.List.RemoveTimeline(ctx, listID); err != nil {
log.Errorf(ctx, "error invalidating list timeline: %q", err)
}
}
return nil
}

521
internal/db/bundb/list_test.go
View file

@ -18,334 +18,329 @@
package bundb_test
import (
"context"
"slices"
"testing"
"github.com/stretchr/testify/suite"
"github.com/superseriousbusiness/gotosocial/internal/db"
"github.com/superseriousbusiness/gotosocial/internal/gtscontext"
"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
)
type ListTestSuite struct {
BunDBStandardTestSuite
}
func (suite *ListTestSuite) testStructs() (*gtsmodel.List, *gtsmodel.Account) {
testList := &gtsmodel.List{}
*testList = *suite.testLists["local_account_1_list_1"]
// func (suite *ListTestSuite) testStructs() (*gtsmodel.List, *gtsmodel.Account) {
// testList := &gtsmodel.List{}
// *testList = *suite.testLists["local_account_1_list_1"]
// Populate entries on this list as we'd expect them back from the db.
entries := make([]*gtsmodel.ListEntry, 0, len(suite.testListEntries))
for _, entry := range suite.testListEntries {
entries = append(entries, entry)
}
// // Populate entries on this list as we'd expect them back from the db.
// entries := make([]*gtsmodel.ListEntry, 0, len(suite.testListEntries))
// for _, entry := range suite.testListEntries {
// entries = append(entries, entry)
// }
// Sort by ID descending (again, as we'd expect from the db).
slices.SortFunc(entries, func(a, b *gtsmodel.ListEntry) int {
const k = -1
switch {
case a.ID > b.ID:
return +k
case a.ID < b.ID:
return -k
default:
return 0
}
})
// // Sort by ID descending (again, as we'd expect from the db).
// slices.SortFunc(entries, func(a, b *gtsmodel.ListEntry) int {
// const k = -1
// switch {
// case a.ID > b.ID:
// return +k
// case a.ID < b.ID:
// return -k
// default:
// return 0
// }
// })
testList.ListEntries = entries
// testList.ListEntries = entries
testAccount := &gtsmodel.Account{}
*testAccount = *suite.testAccounts["local_account_1"]
// testAccount := &gtsmodel.Account{}
// *testAccount = *suite.testAccounts["local_account_1"]
return testList, testAccount
}
// return testList, testAccount
// }
func (suite *ListTestSuite) checkList(expected *gtsmodel.List, actual *gtsmodel.List) {
suite.Equal(expected.ID, actual.ID)
suite.Equal(expected.Title, actual.Title)
suite.Equal(expected.AccountID, actual.AccountID)
suite.Equal(expected.RepliesPolicy, actual.RepliesPolicy)
suite.NotNil(actual.Account)
}
// func (suite *ListTestSuite) checkList(expected *gtsmodel.List, actual *gtsmodel.List) {
// suite.Equal(expected.ID, actual.ID)
// suite.Equal(expected.Title, actual.Title)
// suite.Equal(expected.AccountID, actual.AccountID)
// suite.Equal(expected.RepliesPolicy, actual.RepliesPolicy)
// suite.NotNil(actual.Account)
// }
func (suite *ListTestSuite) checkListEntry(expected *gtsmodel.ListEntry, actual *gtsmodel.ListEntry) {
suite.Equal(expected.ID, actual.ID)
suite.Equal(expected.ListID, actual.ListID)
suite.Equal(expected.FollowID, actual.FollowID)
}
// func (suite *ListTestSuite) checkListEntry(expected *gtsmodel.ListEntry, actual *gtsmodel.ListEntry) {
// suite.Equal(expected.ID, actual.ID)
// suite.Equal(expected.ListID, actual.ListID)
// suite.Equal(expected.FollowID, actual.FollowID)
// }
func (suite *ListTestSuite) checkListEntries(expected []*gtsmodel.ListEntry, actual []*gtsmodel.ListEntry) {
var (
lExpected = len(expected)
lActual = len(actual)
)
// func (suite *ListTestSuite) checkListEntries(expected []*gtsmodel.ListEntry, actual []*gtsmodel.ListEntry) {
// var (
// lExpected = len(expected)
// lActual = len(actual)
// )
if lExpected != lActual {
suite.FailNow("", "expected %d list entries, got %d", lExpected, lActual)
}
// if lExpected != lActual {
// suite.FailNow("", "expected %d list entries, got %d", lExpected, lActual)
// }
var topID string
for i, expectedEntry := range expected {
actualEntry := actual[i]
// var topID string
// for i, expectedEntry := range expected {
// actualEntry := actual[i]
// Ensure ID descending.
if topID == "" {
topID = actualEntry.ID
} else {
suite.Less(actualEntry.ID, topID)
}
// // Ensure ID descending.
// if topID == "" {
// topID = actualEntry.ID
// } else {
// suite.Less(actualEntry.ID, topID)
// }
suite.checkListEntry(expectedEntry, actualEntry)
}
}
// suite.checkListEntry(expectedEntry, actualEntry)
// }
// }
func (suite *ListTestSuite) TestGetListByID() {
testList, _ := suite.testStructs()
// func (suite *ListTestSuite) TestGetListByID() {
// testList, _ := suite.testStructs()
dbList, err := suite.db.GetListByID(context.Background(), testList.ID)
if err != nil {
suite.FailNow(err.Error())
}
// dbList, err := suite.db.GetListByID(context.Background(), testList.ID)
// if err != nil {
// suite.FailNow(err.Error())
// }
suite.checkList(testList, dbList)
suite.checkListEntries(testList.ListEntries, dbList.ListEntries)
}
// suite.checkList(testList, dbList)
// suite.checkListEntries(testList.ListEntries, dbList.ListEntries)
// }
func (suite *ListTestSuite) TestGetListsForAccountID() {
testList, testAccount := suite.testStructs()
// func (suite *ListTestSuite) TestGetListsForAccountID() {
// testList, testAccount := suite.testStructs()
dbLists, err := suite.db.GetListsForAccountID(context.Background(), testAccount.ID)
if err != nil {
suite.FailNow(err.Error())
}
// dbLists, err := suite.db.GetListsForAccountID(context.Background(), testAccount.ID)
// if err != nil {
// suite.FailNow(err.Error())
// }
if l := len(dbLists); l != 1 {
suite.FailNow("", "expected %d lists, got %d", 1, l)
}
// if l := len(dbLists); l != 1 {
// suite.FailNow("", "expected %d lists, got %d", 1, l)
// }
suite.checkList(testList, dbLists[0])
}
// suite.checkList(testList, dbLists[0])
// }
func (suite *ListTestSuite) TestGetListEntries() {
testList, _ := suite.testStructs()
// func (suite *ListTestSuite) TestGetListEntries() {
// testList, _ := suite.testStructs()
dbListEntries, err := suite.db.GetListEntries(context.Background(), testList.ID, "", "", "", 0)
if err != nil {
suite.FailNow(err.Error())
}
// dbListEntries, err := suite.db.GetListEntries(context.Background(), testList.ID, "", "", "", 0)
// if err != nil {
// suite.FailNow(err.Error())
// }
suite.checkListEntries(testList.ListEntries, dbListEntries)
}
// suite.checkListEntries(testList.ListEntries, dbListEntries)
// }
func (suite *ListTestSuite) TestPutList() {
ctx := context.Background()
_, testAccount := suite.testStructs()
// func (suite *ListTestSuite) TestPutList() {
// ctx := context.Background()
// _, testAccount := suite.testStructs()
testList := &gtsmodel.List{
ID: "01H0J2PMYM54618VCV8Y8QYAT4",
Title: "Test List!",
AccountID: testAccount.ID,
}
// testList := &gtsmodel.List{
// ID: "01H0J2PMYM54618VCV8Y8QYAT4",
// Title: "Test List!",
// AccountID: testAccount.ID,
// }
if err := suite.db.PutList(ctx, testList); err != nil {
suite.FailNow(err.Error())
}
// if err := suite.db.PutList(ctx, testList); err != nil {
// suite.FailNow(err.Error())
// }
dbList, err := suite.db.GetListByID(ctx, testList.ID)
if err != nil {
suite.FailNow(err.Error())
}
// dbList, err := suite.db.GetListByID(ctx, testList.ID)
// if err != nil {
// suite.FailNow(err.Error())
// }
// Bodge testlist as though default had been set.
testList.RepliesPolicy = gtsmodel.RepliesPolicyFollowed
suite.checkList(testList, dbList)
}
// // Bodge testlist as though default had been set.
// testList.RepliesPolicy = gtsmodel.RepliesPolicyFollowed
// suite.checkList(testList, dbList)
// }
func (suite *ListTestSuite) TestUpdateList() {
ctx := context.Background()
testList, _ := suite.testStructs()
// func (suite *ListTestSuite) TestUpdateList() {
// ctx := context.Background()
// testList, _ := suite.testStructs()
// Get List in the cache first.
dbList, err := suite.db.GetListByID(ctx, testList.ID)
if err != nil {
suite.FailNow(err.Error())
}
// // Get List in the cache first.
// dbList, err := suite.db.GetListByID(ctx, testList.ID)
// if err != nil {
// suite.FailNow(err.Error())
// }
// Now do the update.
testList.Title = "New Title!"
if err := suite.db.UpdateList(ctx, testList, "title"); err != nil {
suite.FailNow(err.Error())
}
// // Now do the update.
// testList.Title = "New Title!"
// if err := suite.db.UpdateList(ctx, testList, "title"); err != nil {
// suite.FailNow(err.Error())
// }
// Cache should be invalidated
// + we should have updated list.
dbList, err = suite.db.GetListByID(ctx, testList.ID)
if err != nil {
suite.FailNow(err.Error())
}
// // Cache should be invalidated
// // + we should have updated list.
// dbList, err = suite.db.GetListByID(ctx, testList.ID)
// if err != nil {
// suite.FailNow(err.Error())
// }
suite.checkList(testList, dbList)
}
// suite.checkList(testList, dbList)
// }
func (suite *ListTestSuite) TestDeleteList() {
ctx := context.Background()
testList, _ := suite.testStructs()
// func (suite *ListTestSuite) TestDeleteList() {
// ctx := context.Background()
// testList, _ := suite.testStructs()
// Get List in the cache first.
if _, err := suite.db.GetListByID(ctx, testList.ID); err != nil {
suite.FailNow(err.Error())
}
// // Get List in the cache first.
// if _, err := suite.db.GetListByID(ctx, testList.ID); err != nil {
// suite.FailNow(err.Error())
// }
// Now do the delete.
if err := suite.db.DeleteListByID(ctx, testList.ID); err != nil {
suite.FailNow(err.Error())
}
// // Now do the delete.
// if err := suite.db.DeleteListByID(ctx, testList.ID); err != nil {
// suite.FailNow(err.Error())
// }
// Cache should be invalidated
// + we should have no list.
_, err := suite.db.GetListByID(ctx, testList.ID)
suite.ErrorIs(err, db.ErrNoEntries)
// // Cache should be invalidated
// // + we should have no list.
// _, err := suite.db.GetListByID(ctx, testList.ID)
// suite.ErrorIs(err, db.ErrNoEntries)
// All entries belonging to this
// list should now be deleted.
listEntries, err := suite.db.GetListEntries(ctx, testList.ID, "", "", "", 0)
if err != nil {
suite.FailNow(err.Error())
}
suite.Empty(listEntries)
}
// // All entries belonging to this
// // list should now be deleted.
// listEntries, err := suite.db.GetListEntries(ctx, testList.ID, "", "", "", 0)
// if err != nil {
// suite.FailNow(err.Error())
// }
// suite.Empty(listEntries)
// }
func (suite *ListTestSuite) TestPutListEntries() {
ctx := context.Background()
testList, _ := suite.testStructs()
// func (suite *ListTestSuite) TestPutListEntries() {
// ctx := context.Background()
// testList, _ := suite.testStructs()
listEntries := []*gtsmodel.ListEntry{
{
ID: "01H0MKMQY69HWDSDR2SWGA17R4",
ListID: testList.ID,
FollowID: "01H0MKNFRFZS8R9WV6DBX31Y03", // random id, doesn't exist
},
{
ID: "01H0MKPGQF0E7QAVW5BKTHZ630",
ListID: testList.ID,
FollowID: "01H0MKP6RR8VEHN3GVWFBP2H30", // random id, doesn't exist
},
{
ID: "01H0MKPPP2DT68FRBMR1FJM32T",
ListID: testList.ID,
FollowID: "01H0MKQ0KA29C6NFJ27GTZD16J", // random id, doesn't exist
},
}
// listEntries := []*gtsmodel.ListEntry{
// {
// ID: "01H0MKMQY69HWDSDR2SWGA17R4",
// ListID: testList.ID,
// FollowID: "01H0MKNFRFZS8R9WV6DBX31Y03", // random id, doesn't exist
// },
// {
// ID: "01H0MKPGQF0E7QAVW5BKTHZ630",
// ListID: testList.ID,
// FollowID: "01H0MKP6RR8VEHN3GVWFBP2H30", // random id, doesn't exist
// },
// {
// ID: "01H0MKPPP2DT68FRBMR1FJM32T",
// ListID: testList.ID,
// FollowID: "01H0MKQ0KA29C6NFJ27GTZD16J", // random id, doesn't exist
// },
// }
if err := suite.db.PutListEntries(ctx, listEntries); err != nil {
suite.FailNow(err.Error())
}
// if err := suite.db.PutListEntries(ctx, listEntries); err != nil {
// suite.FailNow(err.Error())
// }
// Add these entries to the test list, sort it again
// to reflect what we'd expect to get from the db.
testList.ListEntries = append(testList.ListEntries, listEntries...)
slices.SortFunc(testList.ListEntries, func(a, b *gtsmodel.ListEntry) int {
const k = -1
switch {
case a.ID > b.ID:
return +k
case a.ID < b.ID:
return -k
default:
return 0
}
})
// // Add these entries to the test list, sort it again
// // to reflect what we'd expect to get from the db.
// testList.ListEntries = append(testList.ListEntries, listEntries...)
// slices.SortFunc(testList.ListEntries, func(a, b *gtsmodel.ListEntry) int {
// const k = -1
// switch {
// case a.ID > b.ID:
// return +k
// case a.ID < b.ID:
// return -k
// default:
// return 0
// }
// })
// Now get all list entries from the db.
// Use barebones for this because the ones
// we just added will fail if we try to get
// the nonexistent follows.
dbListEntries, err := suite.db.GetListEntries(
gtscontext.SetBarebones(ctx),
testList.ID,
"", "", "", 0)
if err != nil {
suite.FailNow(err.Error())
}
// // Now get all list entries from the db.
// // Use barebones for this because the ones
// // we just added will fail if we try to get
// // the nonexistent follows.
// dbListEntries, err := suite.db.GetListEntries(
// gtscontext.SetBarebones(ctx),
// testList.ID,
// "", "", "", 0)
// if err != nil {
// suite.FailNow(err.Error())
// }
suite.checkListEntries(testList.ListEntries, dbListEntries)
}
// suite.checkListEntries(testList.ListEntries, dbListEntries)
// }
func (suite *ListTestSuite) TestDeleteListEntry() {
ctx := context.Background()
testList, _ := suite.testStructs()
// func (suite *ListTestSuite) TestDeleteListEntry() {
// ctx := context.Background()
// testList, _ := suite.testStructs()
// Get List in the cache first.
if _, err := suite.db.GetListByID(ctx, testList.ID); err != nil {
suite.FailNow(err.Error())
}
// // Get List in the cache first.
// if _, err := suite.db.GetListByID(ctx, testList.ID); err != nil {
// suite.FailNow(err.Error())
// }
// Delete the first entry.
if err := suite.db.DeleteListEntry(ctx, testList.ListEntries[0].ID); err != nil {
suite.FailNow(err.Error())
}
// // Delete the first entry.
// if err := suite.db.DeleteListEntry(ctx, testList.ListEntries[0].ID); err != nil {
// suite.FailNow(err.Error())
// }
// Get list from the db again.
dbList, err := suite.db.GetListByID(ctx, testList.ID)
if err != nil {
suite.FailNow(err.Error())
}
// // Get list from the db again.
// dbList, err := suite.db.GetListByID(ctx, testList.ID)
// if err != nil {
// suite.FailNow(err.Error())
// }
// Bodge the testlist as though
// we'd removed the first entry.
testList.ListEntries = testList.ListEntries[1:]
suite.checkList(testList, dbList)
}
// // Bodge the testlist as though
// // we'd removed the first entry.
// testList.ListEntries = testList.ListEntries[1:]
// suite.checkList(testList, dbList)
// }
func (suite *ListTestSuite) TestDeleteListEntriesForFollowID() {
ctx := context.Background()
testList, _ := suite.testStructs()
// func (suite *ListTestSuite) TestDeleteListEntriesForFollowID() {
// ctx := context.Background()
// testList, _ := suite.testStructs()
// Get List in the cache first.
if _, err := suite.db.GetListByID(ctx, testList.ID); err != nil {
suite.FailNow(err.Error())
}
// // Get List in the cache first.
// if _, err := suite.db.GetListByID(ctx, testList.ID); err != nil {
// suite.FailNow(err.Error())
// }
// Delete the first entry.
if err := suite.db.DeleteListEntriesForFollowID(ctx, testList.ListEntries[0].FollowID); err != nil {
suite.FailNow(err.Error())
}
// // Delete the first entry.
// if err := suite.db.DeleteListEntriesTargettingFollowID(ctx, testList.ListEntries[0].FollowID); err != nil {
// suite.FailNow(err.Error())
// }
// Get list from the db again.
dbList, err := suite.db.GetListByID(ctx, testList.ID)
if err != nil {
suite.FailNow(err.Error())
}
// // Get list from the db again.
// dbList, err := suite.db.GetListByID(ctx, testList.ID)
// if err != nil {
// suite.FailNow(err.Error())
// }
// Bodge the testlist as though
// we'd removed the first entry.
testList.ListEntries = testList.ListEntries[1:]
suite.checkList(testList, dbList)
}
// // Bodge the testlist as though
// // we'd removed the first entry.
// testList.ListEntries = testList.ListEntries[1:]
// suite.checkList(testList, dbList)
// }
func (suite *ListTestSuite) TestListIncludesAccount() {
ctx := context.Background()
testList, _ := suite.testStructs()
// func (suite *ListTestSuite) TestListIncludesAccount() {
// ctx := context.Background()
// testList, _ := suite.testStructs()
for accountID, expected := range map[string]bool{
suite.testAccounts["admin_account"].ID: true,
suite.testAccounts["local_account_1"].ID: false,
suite.testAccounts["local_account_2"].ID: true,
"01H7074GEZJ56J5C86PFB0V2CT": false,
} {
includes, err := suite.db.ListIncludesAccount(ctx, testList.ID, accountID)
if err != nil {
suite.FailNow(err.Error())
}
// for accountID, expected := range map[string]bool{
// suite.testAccounts["admin_account"].ID: true,
// suite.testAccounts["local_account_1"].ID: false,
// suite.testAccounts["local_account_2"].ID: true,
// "01H7074GEZJ56J5C86PFB0V2CT": false,
// } {
// includes, err := suite.db.ListIncludesAccount(ctx, testList.ID, accountID)
// if err != nil {
// suite.FailNow(err.Error())
// }
if includes != expected {
suite.FailNow("", "expected %t for accountID %s got %t", expected, accountID, includes)
}
}
}
// if includes != expected {
// suite.FailNow("", "expected %t for accountID %s got %t", expected, accountID, includes)
// }
// }
// }
func TestListTestSuite(t *testing.T) {
suite.Run(t, new(ListTestSuite))

4
internal/db/bundb/relationship_follow.go
View file

@ -262,7 +262,7 @@ func (r *relationshipDB) deleteFollow(ctx context.Context, id string) error {
}
// Delete every list entry that used this followID.
if err := r.state.DB.DeleteListEntriesForFollowID(ctx, id); err != nil {
if err := r.state.DB.DeleteListEntriesTargettingFollowID(ctx, id); err != nil {
return fmt.Errorf("deleteFollow: error deleting list entries: %w", err)
}
@ -382,7 +382,7 @@ func (r *relationshipDB) DeleteAccountFollows(ctx context.Context, accountID str
for _, id := range followIDs {
// Finally, delete all list entries associated with each follow ID.
if err := r.state.DB.DeleteListEntriesForFollowID(ctx, id); err != nil {
if err := r.state.DB.DeleteListEntriesTargettingFollowID(ctx, id); err != nil {
return err
}
}

12
internal/db/bundb/relationship_test.go
View file

@ -826,10 +826,10 @@ func (suite *RelationshipTestSuite) TestUnfollowExisting() {
suite.NotNil(follow)
followID := follow.ID
// We should have list entries for this follow.
listEntries, err := suite.db.GetListEntriesForFollowID(context.Background(), followID)
// We should have lists that this follow is a part of.
lists, err := suite.db.GetListsWithFollowID(context.Background(), followID)
suite.NoError(err)
suite.NotEmpty(listEntries)
suite.NotEmpty(lists)
err = suite.db.DeleteFollowByID(context.Background(), followID)
suite.NoError(err)
@ -838,10 +838,10 @@ func (suite *RelationshipTestSuite) TestUnfollowExisting() {
suite.EqualError(err, db.ErrNoEntries.Error())
suite.Nil(follow)
// ListEntries pertaining to this follow should be deleted too.
listEntries, err = suite.db.GetListEntriesForFollowID(context.Background(), followID)
// Lists containing this follow should return empty too.
lists, err = suite.db.GetListsWithFollowID(context.Background(), followID)
suite.NoError(err)
suite.Empty(listEntries)
suite.Empty(lists)
}
func (suite *RelationshipTestSuite) TestGetFollowNotExisting() {

75
internal/db/bundb/tag.go
View file

@ -20,6 +20,7 @@ package bundb
import (
"context"
"errors"
"slices"
"strings"
"github.com/superseriousbusiness/gotosocial/internal/db"
@ -148,17 +149,11 @@ func (t *tagDB) GetFollowedTags(ctx context.Context, accountID string, page *pag
if err != nil {
return nil, err
}
tags, err := t.GetTags(ctx, tagIDs)
if err != nil {
return nil, err
}
return tags, nil
return t.GetTags(ctx, tagIDs)
}
func (t *tagDB) getTagIDsFollowedByAccount(ctx context.Context, accountID string, page *paging.Page) ([]string, error) {
return loadPagedIDs(&t.state.Caches.DB.TagIDsFollowedByAccount, accountID, page, func() ([]string, error) {
return loadPagedIDs(&t.state.Caches.DB.FollowingTagIDs, ">"+accountID, page, func() ([]string, error) {
var tagIDs []string
// Tag IDs not in cache. Perform DB query.
@ -178,7 +173,7 @@ func (t *tagDB) getTagIDsFollowedByAccount(ctx context.Context, accountID string
}
func (t *tagDB) getAccountIDsFollowingTag(ctx context.Context, tagID string) ([]string, error) {
return loadPagedIDs(&t.state.Caches.DB.AccountIDsFollowingTag, tagID, nil, func() ([]string, error) {
return loadPagedIDs(&t.state.Caches.DB.FollowingTagIDs, "<"+tagID, nil, func() ([]string, error) {
var accountIDs []string
// Account IDs not in cache. Perform DB query.
@ -198,18 +193,17 @@ func (t *tagDB) getAccountIDsFollowingTag(ctx context.Context, tagID string) ([]
}
func (t *tagDB) IsAccountFollowingTag(ctx context.Context, accountID string, tagID string) (bool, error) {
accountTagIDs, err := t.getTagIDsFollowedByAccount(ctx, accountID, nil)
followingTagIDs, err := t.getTagIDsFollowedByAccount(ctx, accountID, nil)
if err != nil {
return false, err
}
for _, accountTagID := range accountTagIDs {
if accountTagID == tagID {
return true, nil
}
}
return false, nil
// NOTE: it should only become useful to cache
// FollowedTag{} objects separately here (for
// caching by AccountID.TagID) only if the number
// of accounts following a tag becomes rather ridiculous,
// i.e. in the order of thousands. So we should be good.
return slices.Contains(followingTagIDs, tagID), nil
}
func (t *tagDB) PutFollowedTag(ctx context.Context, accountID string, tagID string) error {
@ -234,9 +228,15 @@ func (t *tagDB) PutFollowedTag(ctx context.Context, accountID string, tagID stri
return nil
}
// Otherwise, this is a new followed tag, so we invalidate caches related to it.
t.state.Caches.DB.AccountIDsFollowingTag.Invalidate(tagID)
t.state.Caches.DB.TagIDsFollowedByAccount.Invalidate(accountID)
// If we deleted anything, invalidate caches.
t.state.Caches.DB.FollowingTagIDs.Invalidate(
// tag IDs followed by account
">"+accountID,
// account IDs following tag
"<"+tagID,
)
return nil
}
@ -259,9 +259,15 @@ func (t *tagDB) DeleteFollowedTag(ctx context.Context, accountID string, tagID s
return nil
}
// If we deleted anything, invalidate caches related to it.
t.state.Caches.DB.AccountIDsFollowingTag.Invalidate(tagID)
t.state.Caches.DB.TagIDsFollowedByAccount.Invalidate(accountID)
// If we deleted anything, invalidate caches.
t.state.Caches.DB.FollowingTagIDs.Invalidate(
// tag IDs followed by account
">"+accountID,
// account IDs following tag
"<"+tagID,
)
return err
}
@ -278,16 +284,26 @@ func (t *tagDB) DeleteFollowedTagsByAccountID(ctx context.Context, accountID str
return gtserror.Newf("error deleting followed tags for account %s: %w", accountID, err)
}
// Invalidate account ID caches for the account and those tags.
t.state.Caches.DB.TagIDsFollowedByAccount.Invalidate(accountID)
t.state.Caches.DB.AccountIDsFollowingTag.Invalidate(tagIDs...)
// Convert tag IDs to the keys
// we use for caching tag follow
// and following IDs.
keys := tagIDs
for i := range keys {
keys[i] = "<" + keys[i]
}
keys = append(keys, ">"+accountID)
// If we deleted anything, invalidate caches with keys.
t.state.Caches.DB.FollowingTagIDs.Invalidate(keys...)
return nil
}
func (t *tagDB) GetAccountIDsFollowingTagIDs(ctx context.Context, tagIDs []string) ([]string, error) {
// Accounts might be following multiple tags in this list, but we only want to return each account once.
accountIDs := []string{}
// Make conservative estimate for no. accounts.
accountIDs := make([]string, 0, len(tagIDs))
// Gather all accounts following tags.
for _, tagID := range tagIDs {
tagAccountIDs, err := t.getAccountIDsFollowingTag(ctx, tagID)
if err != nil {
@ -295,5 +311,8 @@ func (t *tagDB) GetAccountIDsFollowingTagIDs(ctx context.Context, tagIDs []strin
}
accountIDs = append(accountIDs, tagAccountIDs...)
}
// Accounts might be following multiple tags in list,
// but we only want to return each account once.
return util.Deduplicate(accountIDs), nil
}

22
internal/db/bundb/timeline.go
View file

@ -370,30 +370,20 @@ func (t *timelineDB) GetListTimeline(
frontToBack = true
)
// Fetch all listEntries entries from the database.
listEntries, err := t.state.DB.GetListEntries(
// Don't need actual follows
// for this, just the IDs.
gtscontext.SetBarebones(ctx),
listID,
"", "", "", 0,
// Fetch all follow IDs contained in list from DB.
followIDs, err := t.state.DB.GetFollowIDsInList(
ctx, listID, nil,
)
if err != nil {
return nil, fmt.Errorf("error getting entries for list %s: %w", listID, err)
return nil, fmt.Errorf("error getting follows in list: %w", err)
}
// If there's no list entries we can't
// If there's no list follows we can't
// possibly return anything for this list.
if len(listEntries) == 0 {
if len(followIDs) == 0 {
return make([]*gtsmodel.Status, 0), nil
}
// Extract just the IDs of each follow.
followIDs := make([]string, 0, len(listEntries))
for _, listEntry := range listEntries {
followIDs = append(followIDs, listEntry.FollowID)
}
// Select target account IDs from follows.
subQ := t.db.
NewSelect().

51
internal/db/list.go
View file

@ -21,6 +21,7 @@ import (
"context"
"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
"github.com/superseriousbusiness/gotosocial/internal/paging"
)
type List interface {
@ -30,11 +31,29 @@ type List interface {
// GetListsByIDs fetches all lists with the provided IDs.
GetListsByIDs(ctx context.Context, ids []string) ([]*gtsmodel.List, error)
// GetListsForAccountID gets all lists owned by the given accountID.
GetListsForAccountID(ctx context.Context, accountID string) ([]*gtsmodel.List, error)
// GetListsByAccountID gets all lists owned by the given accountID.
GetListsByAccountID(ctx context.Context, accountID string) ([]*gtsmodel.List, error)
// CountListsForAccountID counts the number of lists owned by the given accountID.
CountListsForAccountID(ctx context.Context, accountID string) (int, error)
// CountListsByAccountID counts the number of lists owned by the given accountID.
CountListsByAccountID(ctx context.Context, accountID string) (int, error)
// GetListsWithFollowID gets all lists that contain the given follow with ID.
GetListsWithFollowID(ctx context.Context, followID string) ([]*gtsmodel.List, error)
// GetFollowIDsInList returns all the follow IDs contained within given list ID.
GetFollowIDsInList(ctx context.Context, listID string, page *paging.Page) ([]string, error)
// GetFollowsInList returns all the follows contained within given list ID.
GetFollowsInList(ctx context.Context, listID string, page *paging.Page) ([]*gtsmodel.Follow, error)
// GetAccountIDsInList return all the account IDs (follow targets) contained within given list ID.
GetAccountIDsInList(ctx context.Context, listID string, page *paging.Page) ([]string, error)
// GetAccountsInList return all the accounts (follow targets) contained within given list ID.
GetAccountsInList(ctx context.Context, listID string, page *paging.Page) ([]*gtsmodel.Account, error)
// IsAccountInListID returns whether given account with ID is in the list with ID.
IsAccountInListID(ctx context.Context, listID string, accountID string) (bool, error)
// PopulateList ensures that the list's struct fields are populated.
PopulateList(ctx context.Context, list *gtsmodel.List) error
@ -49,31 +68,13 @@ type List interface {
// DeleteListByID deletes one list with the given ID.
DeleteListByID(ctx context.Context, id string) error
// GetListEntryByID gets one list entry with the given ID.
GetListEntryByID(ctx context.Context, id string) (*gtsmodel.ListEntry, error)
// GetListEntriesyIDs fetches all list entries with the provided IDs.
GetListEntriesByIDs(ctx context.Context, ids []string) ([]*gtsmodel.ListEntry, error)
// GetListEntries gets list entries from the given listID, using the given parameters.
GetListEntries(ctx context.Context, listID string, maxID string, sinceID string, minID string, limit int) ([]*gtsmodel.ListEntry, error)
// GetListEntriesForFollowID returns all listEntries that pertain to the given followID.
GetListEntriesForFollowID(ctx context.Context, followID string) ([]*gtsmodel.ListEntry, error)
// PopulateListEntry ensures that the listEntry's struct fields are populated.
PopulateListEntry(ctx context.Context, listEntry *gtsmodel.ListEntry) error
// PutListEntries inserts a slice of listEntries into the database.
// It uses a transaction to ensure no partial updates.
PutListEntries(ctx context.Context, listEntries []*gtsmodel.ListEntry) error
// DeleteListEntry deletes one list entry with the given id.
DeleteListEntry(ctx context.Context, id string) error
// DeleteListEntry deletes the list entry with given list ID and follow ID.
DeleteListEntry(ctx context.Context, listID string, followID string) error
// DeleteListEntryForFollowID deletes all list entries with the given followID.
DeleteListEntriesForFollowID(ctx context.Context, followID string) error
// ListIncludesAccount returns true if the given listID includes the given accountID.
ListIncludesAccount(ctx context.Context, listID string, accountID string) (bool, error)
DeleteListEntriesTargettingFollowID(ctx context.Context, followID string) error
}

3
internal/db/relationship.go
View file

@ -68,6 +68,9 @@ type Relationship interface {
// GetFollow retrieves a follow if it exists between source and target accounts.
GetFollow(ctx context.Context, sourceAccountID string, targetAccountID string) (*gtsmodel.Follow, error)
// GetFollowsByIDs fetches all follows from database with given IDs.
GetFollowsByIDs(ctx context.Context, ids []string) ([]*gtsmodel.Follow, error)
// PopulateFollow populates the struct pointers on the given follow.
PopulateFollow(ctx context.Context, follow *gtsmodel.Follow) error