Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.
Go dockerfossgomarkdownmemomicroblognote-takingnotesopen-sourceown-your-datareactself-hostedsqlitetimeline
perf: batch load memo relations when listing memos (#5692)
memoclaw1e82714a52c7
diff --git a/server/router/api/v1/memo_service.go b/server/router/api/v1/memo_service.goindex ee82ea22e..f563dde68 100644--- a/server/router/api/v1/memo_service.go+++ b/server/router/api/v1/memo_service.go@@ -126,7 +126,11 @@ func (s *APIV1Service) CreateMemo(ctx context.Context, request *v1pb.CreateMemoR}}- memoMessage, err := s.convertMemoFromStore(ctx, memo, nil, attachments)+ relations, err := s.loadMemoRelations(ctx, memo)+ if err != nil {+ return nil, errors.Wrap(err, "failed to load memo relations")+ }+ memoMessage, err := s.convertMemoFromStore(ctx, memo, nil, attachments, relations)if err != nil {return nil, errors.Wrap(err, "failed to convert memo")}@@ -266,12 +270,19 @@ func (s *APIV1Service) ListMemos(ctx context.Context, request *v1pb.ListMemosReqattachmentMap[*attachment.MemoID] = append(attachmentMap[*attachment.MemoID], attachment)}+ // RELATIONS (batch load to avoid N+1)+ relationMap, err := s.batchConvertMemoRelations(ctx, memos)+ if err != nil {+ return nil, status.Errorf(codes.Internal, "failed to batch load memo relations")+ }+for _, memo := range memos {memoName := fmt.Sprintf("%s%s", MemoNamePrefix, memo.UID)reactions := reactionMap[memoName]attachments := attachmentMap[memo.ID]+ relations := relationMap[memo.ID]- memoMessage, err := s.convertMemoFromStore(ctx, memo, reactions, attachments)+ memoMessage, err := s.convertMemoFromStore(ctx, memo, reactions, attachments, relations)if err != nil {return nil, errors.Wrap(err, "failed to convert memo")}@@ -327,7 +338,11 @@ func (s *APIV1Service) GetMemo(ctx context.Context, request *v1pb.GetMemoRequestreturn nil, status.Errorf(codes.Internal, "failed to list attachments")}- memoMessage, err := s.convertMemoFromStore(ctx, memo, reactions, attachments)+ relations, err := s.loadMemoRelations(ctx, memo)+ if err != nil {+ return nil, errors.Wrap(err, "failed to load memo relations")+ }+ memoMessage, err := s.convertMemoFromStore(ctx, memo, reactions, attachments, relations)if err != nil {return nil, errors.Wrap(err, "failed to convert memo")}@@ -462,7 +477,11 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoRreturn nil, status.Errorf(codes.Internal, "failed to list attachments")}- memoMessage, err := s.convertMemoFromStore(ctx, memo, reactions, attachments)+ relations, err := s.loadMemoRelations(ctx, memo)+ if err != nil {+ return nil, errors.Wrap(err, "failed to load memo relations")+ }+ memoMessage, err := s.convertMemoFromStore(ctx, memo, reactions, attachments, relations)if err != nil {return nil, errors.Wrap(err, "failed to convert memo")}@@ -521,7 +540,8 @@ func (s *APIV1Service) DeleteMemo(ctx context.Context, request *v1pb.DeleteMemoRreturn nil, status.Errorf(codes.Internal, "failed to list attachments")}- if memoMessage, err := s.convertMemoFromStore(ctx, memo, reactions, attachments); err == nil {+ deleteRelations, _ := s.loadMemoRelations(ctx, memo)+ if memoMessage, err := s.convertMemoFromStore(ctx, memo, reactions, attachments, deleteRelations); err == nil {// Try to dispatch webhook when memo is deleted.if err := s.DispatchMemoDeletedWebhook(ctx, memoMessage); err != nil {slog.Warn("Failed to dispatch memo deleted webhook", slog.Any("err", err))@@ -725,13 +745,20 @@ func (s *APIV1Service) ListMemoComments(ctx context.Context, request *v1pb.ListMattachmentMap[*attachment.MemoID] = append(attachmentMap[*attachment.MemoID], attachment)}+ // RELATIONS (batch load to avoid N+1)+ relationMap, err := s.batchConvertMemoRelations(ctx, memos)+ if err != nil {+ return nil, status.Errorf(codes.Internal, "failed to batch load memo relations")+ }+var memosResponse []*v1pb.Memofor _, m := range memos {memoName := memoIDToNameMap[m.ID]reactions := memoReactionsMap[memoName]attachments := attachmentMap[m.ID]+ relations := relationMap[m.ID]- memoMessage, err := s.convertMemoFromStore(ctx, m, reactions, attachments)+ memoMessage, err := s.convertMemoFromStore(ctx, m, reactions, attachments, relations)if err != nil {return nil, errors.Wrap(err, "failed to convert memo")}diff --git a/server/router/api/v1/memo_service_converter.go b/server/router/api/v1/memo_service_converter.goindex 325c1a0b2..fb585c1dc 100644--- a/server/router/api/v1/memo_service_converter.go+++ b/server/router/api/v1/memo_service_converter.go@@ -13,7 +13,7 @@ import ("github.com/usememos/memos/store")-func (s *APIV1Service) convertMemoFromStore(ctx context.Context, memo *store.Memo, reactions []*store.Reaction, attachments []*store.Attachment) (*v1pb.Memo, error) {+func (s *APIV1Service) convertMemoFromStore(ctx context.Context, memo *store.Memo, reactions []*store.Reaction, attachments []*store.Attachment, relations []*v1pb.MemoRelation) (*v1pb.Memo, error) {displayTs := memo.CreatedTsinstanceMemoRelatedSetting, err := s.Store.GetInstanceMemoRelatedSetting(ctx)if err != nil {@@ -47,20 +47,18 @@ func (s *APIV1Service) convertMemoFromStore(ctx context.Context, memo *store.Mem}memoMessage.Reactions = []*v1pb.Reaction{}-for _, reaction := range reactions {reactionResponse := convertReactionFromStore(reaction)memoMessage.Reactions = append(memoMessage.Reactions, reactionResponse)}- listMemoRelationsResponse, err := s.ListMemoRelations(ctx, &v1pb.ListMemoRelationsRequest{Name: name})- if err != nil {- return nil, errors.Wrap(err, "failed to list memo relations")+ if relations != nil {+ memoMessage.Relations = relations+ } else {+ memoMessage.Relations = []*v1pb.MemoRelation{}}- memoMessage.Relations = listMemoRelationsResponse.RelationsmemoMessage.Attachments = []*v1pb.Attachment{}-for _, attachment := range attachments {attachmentResponse := convertAttachmentFromStore(attachment)memoMessage.Attachments = append(memoMessage.Attachments, attachmentResponse)@@ -75,6 +73,116 @@ func (s *APIV1Service) convertMemoFromStore(ctx context.Context, memo *store.Memreturn memoMessage, nil}+// batchConvertMemoRelations batch-loads relations for a list of memos and returns+// a map from memo ID to its converted relations. This avoids N+1 queries when listing memos.+func (s *APIV1Service) batchConvertMemoRelations(ctx context.Context, memos []*store.Memo) (map[int32][]*v1pb.MemoRelation, error) {+ if len(memos) == 0 {+ return map[int32][]*v1pb.MemoRelation{}, nil+ }++ currentUser, err := s.fetchCurrentUser(ctx)+ if err != nil {+ return nil, errors.Wrap(err, "failed to get user")+ }+ var memoFilter string+ if currentUser == nil {+ memoFilter = `visibility == "PUBLIC"`+ } else {+ memoFilter = fmt.Sprintf(`creator_id == %d || visibility in ["PUBLIC", "PROTECTED"]`, currentUser.ID)+ }++ memoIDs := make([]int32, len(memos))+ memoIDSet := make(map[int32]bool, len(memos))+ for i, m := range memos {+ memoIDs[i] = m.ID+ memoIDSet[m.ID] = true+ }++ // Single batch query to get all relations involving any of these memos.+ allRelations, err := s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{+ MemoIDList: memoIDs,+ MemoFilter: &memoFilter,+ })+ if err != nil {+ return nil, errors.Wrap(err, "failed to batch list memo relations")+ }++ // Collect all memo IDs referenced in relations that we need to resolve.+ neededIDs := make(map[int32]bool)+ for _, r := range allRelations {+ neededIDs[r.MemoID] = true+ neededIDs[r.RelatedMemoID] = true+ }++ // Build ID→UID map from the memos we already have.+ memoIDToUID := make(map[int32]string, len(memos))+ memoIDToContent := make(map[int32]string, len(memos))+ for _, m := range memos {+ memoIDToUID[m.ID] = m.UID+ memoIDToContent[m.ID] = m.Content+ delete(neededIDs, m.ID)+ }++ // Batch fetch any additional memos referenced by relations that we don't already have.+ if len(neededIDs) > 0 {+ extraIDs := make([]int32, 0, len(neededIDs))+ for id := range neededIDs {+ extraIDs = append(extraIDs, id)+ }+ extraMemos, err := s.Store.ListMemos(ctx, &store.FindMemo{IDList: extraIDs})+ if err != nil {+ return nil, errors.Wrap(err, "failed to batch fetch related memos")+ }+ for _, m := range extraMemos {+ memoIDToUID[m.ID] = m.UID+ memoIDToContent[m.ID] = m.Content+ }+ }++ // Build the result map: memo ID → its relations (both directions).+ result := make(map[int32][]*v1pb.MemoRelation, len(memos))+ for _, r := range allRelations {+ memoUID, ok1 := memoIDToUID[r.MemoID]+ relatedUID, ok2 := memoIDToUID[r.RelatedMemoID]+ if !ok1 || !ok2 {+ continue+ }++ memoSnippet, _ := s.getMemoContentSnippet(memoIDToContent[r.MemoID])+ relatedSnippet, _ := s.getMemoContentSnippet(memoIDToContent[r.RelatedMemoID])+ relation := &v1pb.MemoRelation{+ Memo: &v1pb.MemoRelation_Memo{+ Name: fmt.Sprintf("%s%s", MemoNamePrefix, memoUID),+ Snippet: memoSnippet,+ },+ RelatedMemo: &v1pb.MemoRelation_Memo{+ Name: fmt.Sprintf("%s%s", MemoNamePrefix, relatedUID),+ Snippet: relatedSnippet,+ },+ Type: convertMemoRelationTypeFromStore(r.Type),+ }++ // Add to the memo that owns this relation (both directions).+ if memoIDSet[r.MemoID] {+ result[r.MemoID] = append(result[r.MemoID], relation)+ }+ if memoIDSet[r.RelatedMemoID] {+ result[r.RelatedMemoID] = append(result[r.RelatedMemoID], relation)+ }+ }++ return result, nil+}++// loadMemoRelations loads relations for a single memo and converts them to API format.+func (s *APIV1Service) loadMemoRelations(ctx context.Context, memo *store.Memo) ([]*v1pb.MemoRelation, error) {+ relationMap, err := s.batchConvertMemoRelations(ctx, []*store.Memo{memo})+ if err != nil {+ return nil, err+ }+ return relationMap[memo.ID], nil+}+func convertMemoPropertyFromStore(property *storepb.MemoPayload_Property) *v1pb.Memo_Property {if property == nil {return nildiff --git a/server/router/api/v1/test/test_helper.go b/server/router/api/v1/test/test_helper.goindex c3afdb38b..94b42b688 100644--- a/server/router/api/v1/test/test_helper.go+++ b/server/router/api/v1/test/test_helper.go@@ -27,13 +27,15 @@ func NewTestService(t *testing.T) *TestService {// Create a test store with SQLitetestStore := teststore.NewTestingStore(ctx, t)- // Create a test profile+ // Create a test profile with a temp directory for file storage,+ // so tests that create attachments don't leave artifacts in the source tree.testProfile := &profile.Profile{Demo: true,Version: "test-1.0.0",InstanceURL: "http://localhost:8080",Driver: "sqlite",DSN: ":memory:",+ Data: t.TempDir(),}// Create APIV1Service with nil grpcServer since we're testing direct callsdiff --git a/store/db/mysql/memo_relation.go b/store/db/mysql/memo_relation.goindex 71b73be6f..5b8c8391a 100644--- a/store/db/mysql/memo_relation.go+++ b/store/db/mysql/memo_relation.go@@ -42,6 +42,18 @@ func (d *DB) ListMemoRelations(ctx context.Context, find *store.FindMemoRelationif find.Type != nil {where, args = append(where, "`type` = ?"), append(args, find.Type)}+ if len(find.MemoIDList) > 0 {+ placeholders := make([]string, len(find.MemoIDList))+ for i, id := range find.MemoIDList {+ placeholders[i] = "?"+ args = append(args, id)+ }+ inClause := strings.Join(placeholders, ", ")+ for _, id := range find.MemoIDList {+ args = append(args, id)+ }+ where = append(where, fmt.Sprintf("(`memo_id` IN (%s) OR `related_memo_id` IN (%s))", inClause, inClause))+ }if find.MemoFilter != nil {engine, err := filter.DefaultEngine()if err != nil {diff --git a/store/db/postgres/memo_relation.go b/store/db/postgres/memo_relation.goindex a2f2817c7..c22c5c786 100644--- a/store/db/postgres/memo_relation.go+++ b/store/db/postgres/memo_relation.go@@ -49,6 +49,20 @@ func (d *DB) ListMemoRelations(ctx context.Context, find *store.FindMemoRelationif find.Type != nil {where, args = append(where, "type = "+placeholder(len(args)+1)), append(args, find.Type)}+ if len(find.MemoIDList) > 0 {+ memoPlaceholders := make([]string, len(find.MemoIDList))+ for i, id := range find.MemoIDList {+ memoPlaceholders[i] = placeholder(len(args) + 1)+ args = append(args, id)+ }+ relatedPlaceholders := make([]string, len(find.MemoIDList))+ for i, id := range find.MemoIDList {+ relatedPlaceholders[i] = placeholder(len(args) + 1)+ args = append(args, id)+ }+ where = append(where, fmt.Sprintf("(memo_id IN (%s) OR related_memo_id IN (%s))",+ strings.Join(memoPlaceholders, ", "), strings.Join(relatedPlaceholders, ", ")))+ }if find.MemoFilter != nil {engine, err := filter.DefaultEngine()if err != nil {diff --git a/store/db/sqlite/memo_relation.go b/store/db/sqlite/memo_relation.goindex 5eed62e74..f65d70118 100644--- a/store/db/sqlite/memo_relation.go+++ b/store/db/sqlite/memo_relation.go@@ -49,6 +49,19 @@ func (d *DB) ListMemoRelations(ctx context.Context, find *store.FindMemoRelationif find.Type != nil {where, args = append(where, "type = ?"), append(args, find.Type)}+ if len(find.MemoIDList) > 0 {+ placeholders := make([]string, len(find.MemoIDList))+ for i, id := range find.MemoIDList {+ placeholders[i] = "?"+ args = append(args, id)+ }+ inClause := strings.Join(placeholders, ", ")+ // Duplicate args for the second IN clause.+ for _, id := range find.MemoIDList {+ args = append(args, id)+ }+ where = append(where, fmt.Sprintf("(memo_id IN (%s) OR related_memo_id IN (%s))", inClause, inClause))+ }if find.MemoFilter != nil {engine, err := filter.DefaultEngine()if err != nil {diff --git a/store/memo_relation.go b/store/memo_relation.goindex 61b022884..0d63ae32a 100644--- a/store/memo_relation.go+++ b/store/memo_relation.go@@ -24,6 +24,8 @@ type FindMemoRelation struct {RelatedMemoID *int32Type *MemoRelationTypeMemoFilter *string+ // MemoIDList matches relations where memo_id OR related_memo_id is in the list.+ MemoIDList []int32}type DeleteMemoRelation struct {diff --git a/store/test/memo_relation_test.go b/store/test/memo_relation_test.goindex 9cfba6997..5abaaa3f0 100644--- a/store/test/memo_relation_test.go+++ b/store/test/memo_relation_test.go@@ -638,6 +638,270 @@ func TestMemoRelationBidirectional(t *testing.T) {ts.Close()}+func TestMemoRelationListByMemoIDList(t *testing.T) {+ t.Parallel()+ ctx := context.Background()+ ts := NewTestingStore(ctx, t)+ user, err := createTestingHostUser(ctx, ts)+ require.NoError(t, err)++ // Create 3 memos.+ memoA, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-a",+ CreatorID: user.ID,+ Content: "memo A content",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ memoB, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-b",+ CreatorID: user.ID,+ Content: "memo B content",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ memoC, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-c",+ CreatorID: user.ID,+ Content: "memo C content",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ memoD, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-d",+ CreatorID: user.ID,+ Content: "memo D content",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ // A -> B (reference)+ _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{+ MemoID: memoA.ID,+ RelatedMemoID: memoB.ID,+ Type: store.MemoRelationReference,+ })+ require.NoError(t, err)++ // A -> C (comment)+ _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{+ MemoID: memoA.ID,+ RelatedMemoID: memoC.ID,+ Type: store.MemoRelationComment,+ })+ require.NoError(t, err)++ // D -> B (reference) — B appears as related_memo_id+ _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{+ MemoID: memoD.ID,+ RelatedMemoID: memoB.ID,+ Type: store.MemoRelationReference,+ })+ require.NoError(t, err)++ // Batch query for memos A and B: should return all 3 relations+ // (A->B because A is in list, A->C because A is in list, D->B because B is in list)+ relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{+ MemoIDList: []int32{memoA.ID, memoB.ID},+ })+ require.NoError(t, err)+ require.Len(t, relations, 3)++ // Batch query for memo C only: should return 1 relation (A->C because C is related_memo_id)+ relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{+ MemoIDList: []int32{memoC.ID},+ })+ require.NoError(t, err)+ require.Len(t, relations, 1)+ require.Equal(t, memoA.ID, relations[0].MemoID)+ require.Equal(t, memoC.ID, relations[0].RelatedMemoID)++ // Batch query for memo D only: should return 1 relation (D->B because D is memo_id)+ relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{+ MemoIDList: []int32{memoD.ID},+ })+ require.NoError(t, err)+ require.Len(t, relations, 1)+ require.Equal(t, memoD.ID, relations[0].MemoID)+ require.Equal(t, memoB.ID, relations[0].RelatedMemoID)++ ts.Close()+}++func TestMemoRelationListByMemoIDListEmpty(t *testing.T) {+ t.Parallel()+ ctx := context.Background()+ ts := NewTestingStore(ctx, t)+ user, err := createTestingHostUser(ctx, ts)+ require.NoError(t, err)++ memo, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-no-relations",+ CreatorID: user.ID,+ Content: "memo with no relations",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ // Batch query with a memo that has no relations.+ relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{+ MemoIDList: []int32{memo.ID},+ })+ require.NoError(t, err)+ require.Len(t, relations, 0)++ // Empty MemoIDList should not filter by MemoIDList (returns based on other filters).+ relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{+ MemoIDList: []int32{},+ })+ require.NoError(t, err)+ require.Len(t, relations, 0)++ ts.Close()+}++func TestMemoRelationListByMemoIDListWithTypeFilter(t *testing.T) {+ t.Parallel()+ ctx := context.Background()+ ts := NewTestingStore(ctx, t)+ user, err := createTestingHostUser(ctx, ts)+ require.NoError(t, err)++ memoA, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-a",+ CreatorID: user.ID,+ Content: "memo A content",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ memoB, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-b",+ CreatorID: user.ID,+ Content: "memo B content",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ memoC, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-c",+ CreatorID: user.ID,+ Content: "memo C content",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ // A -> B (reference)+ _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{+ MemoID: memoA.ID,+ RelatedMemoID: memoB.ID,+ Type: store.MemoRelationReference,+ })+ require.NoError(t, err)++ // A -> C (comment)+ _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{+ MemoID: memoA.ID,+ RelatedMemoID: memoC.ID,+ Type: store.MemoRelationComment,+ })+ require.NoError(t, err)++ // Batch query with type filter: only references+ refType := store.MemoRelationReference+ relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{+ MemoIDList: []int32{memoA.ID},+ Type: &refType,+ })+ require.NoError(t, err)+ require.Len(t, relations, 1)+ require.Equal(t, store.MemoRelationReference, relations[0].Type)++ // Batch query with type filter: only comments+ commentType := store.MemoRelationComment+ relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{+ MemoIDList: []int32{memoA.ID},+ Type: &commentType,+ })+ require.NoError(t, err)+ require.Len(t, relations, 1)+ require.Equal(t, store.MemoRelationComment, relations[0].Type)++ ts.Close()+}++func TestMemoRelationListByMemoIDListBothDirections(t *testing.T) {+ t.Parallel()+ ctx := context.Background()+ ts := NewTestingStore(ctx, t)+ user, err := createTestingHostUser(ctx, ts)+ require.NoError(t, err)++ memoA, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-a",+ CreatorID: user.ID,+ Content: "memo A content",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ memoB, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-b",+ CreatorID: user.ID,+ Content: "memo B content",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ memoX, err := ts.CreateMemo(ctx, &store.Memo{+ UID: "memo-x",+ CreatorID: user.ID,+ Content: "memo X content",+ Visibility: store.Public,+ })+ require.NoError(t, err)++ // X -> A (A appears as related_memo_id)+ _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{+ MemoID: memoX.ID,+ RelatedMemoID: memoA.ID,+ Type: store.MemoRelationReference,+ })+ require.NoError(t, err)++ // A -> B (A appears as memo_id)+ _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{+ MemoID: memoA.ID,+ RelatedMemoID: memoB.ID,+ Type: store.MemoRelationReference,+ })+ require.NoError(t, err)++ // Query with MemoIDList=[A]: should find both relations (A as source and A as target).+ relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{+ MemoIDList: []int32{memoA.ID},+ })+ require.NoError(t, err)+ require.Len(t, relations, 2)++ // Verify we got both directions.+ memoIDs := map[int32]bool{}+ relatedIDs := map[int32]bool{}+ for _, r := range relations {+ memoIDs[r.MemoID] = true+ relatedIDs[r.RelatedMemoID] = true+ }+ require.True(t, memoIDs[memoX.ID], "should include X->A relation")+ require.True(t, memoIDs[memoA.ID], "should include A->B relation")+ require.True(t, relatedIDs[memoA.ID], "should include X->A relation")+ require.True(t, relatedIDs[memoB.ID], "should include A->B relation")++ ts.Close()+}+func TestMemoRelationMultipleRelationsToSameMemo(t *testing.T) {t.Parallel()ctx := context.Background()