Event relations (#2790)

This adds support for tracking `m.relates_to`, as well as adding support
for the various `/room/{roomID}/relations/...` endpoints to the CS API.

syncapi/storage/tables/interface.go

@@ -206,3 +206,22 @@ type Presence interface {
 	GetMaxPresenceID(ctx context.Context, txn *sql.Tx) (pos types.StreamPosition, err error)
 	GetPresenceAfter(ctx context.Context, txn *sql.Tx, after types.StreamPosition, filter gomatrixserverlib.EventFilter) (presences map[string]*types.PresenceInternal, err error)
 }
+
+type Relations interface {
+	// Inserts a relation which refers from the child event ID to the event ID in the given room.
+	// If the relation already exists then this function will do nothing and return no error.
+	InsertRelation(ctx context.Context, txn *sql.Tx, roomID, eventID, childEventID, childEventType, relType string) (err error)
+	// Deletes a relation which already exists as the result of an event redaction. If the relation
+	// does not exist then this function will do nothing and return no error.
+	DeleteRelation(ctx context.Context, txn *sql.Tx, roomID, childEventID string) error
+	// SelectRelationsInRange will return relations grouped by relation type within the given range.
+	// The map is relType -> []entry. If a relType parameter is specified then the results will only
+	// contain relations of that type, otherwise if "" is specified then all relations in the range
+	// will be returned, inclusive of the "to" position but excluding the "from" position. The stream
+	// position returned is the maximum position of the returned results.
+	SelectRelationsInRange(ctx context.Context, txn *sql.Tx, roomID, eventID, relType, eventType string, r types.Range, limit int) (map[string][]types.RelationEntry, types.StreamPosition, error)
+	// SelectMaxRelationID returns the maximum ID of all relations, used to determine what the boundaries
+	// should be if there are no boundaries supplied (i.e. we want to work backwards but don't have a
+	// "from" or want to work forwards and don't have a "to").
+	SelectMaxRelationID(ctx context.Context, txn *sql.Tx) (id int64, err error)
+}

syncapi/storage/tables/relations_test.go

@@ -0,0 +1,186 @@
+package tables_test
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+
+	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/setup/config"
+	"github.com/matrix-org/dendrite/syncapi/storage/postgres"
+	"github.com/matrix-org/dendrite/syncapi/storage/sqlite3"
+	"github.com/matrix-org/dendrite/syncapi/storage/tables"
+	"github.com/matrix-org/dendrite/syncapi/types"
+	"github.com/matrix-org/dendrite/test"
+)
+
+func newRelationsTable(t *testing.T, dbType test.DBType) (tables.Relations, *sql.DB, func()) {
+	t.Helper()
+	connStr, close := test.PrepareDBConnectionString(t, dbType)
+	db, err := sqlutil.Open(&config.DatabaseOptions{
+		ConnectionString: config.DataSource(connStr),
+	}, sqlutil.NewExclusiveWriter())
+	if err != nil {
+		t.Fatalf("failed to open db: %s", err)
+	}
+
+	var tab tables.Relations
+	switch dbType {
+	case test.DBTypePostgres:
+		tab, err = postgres.NewPostgresRelationsTable(db)
+	case test.DBTypeSQLite:
+		var stream sqlite3.StreamIDStatements
+		if err = stream.Prepare(db); err != nil {
+			t.Fatalf("failed to prepare stream stmts: %s", err)
+		}
+		tab, err = sqlite3.NewSqliteRelationsTable(db, &stream)
+	}
+	if err != nil {
+		t.Fatalf("failed to make new table: %s", err)
+	}
+	return tab, db, close
+}
+
+func compareRelationsToExpected(t *testing.T, tab tables.Relations, r types.Range, expected []types.RelationEntry) {
+	ctx := context.Background()
+	relations, _, err := tab.SelectRelationsInRange(ctx, nil, roomID, "a", "", "", r, 50)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(relations[relType]) != len(expected) {
+		t.Fatalf("incorrect number of values returned for range %v (got %d, want %d)", r, len(relations[relType]), len(expected))
+	}
+	for i := 0; i < len(relations[relType]); i++ {
+		got := relations[relType][i]
+		want := expected[i]
+		if got != want {
+			t.Fatalf("range %v position %d should have been %q but got %q", r, i, got, want)
+		}
+	}
+}
+
+const roomID = "!roomid:server"
+const childType = "m.room.something"
+const relType = "m.reaction"
+
+func TestRelationsTable(t *testing.T) {
+	ctx := context.Background()
+	test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {
+		tab, _, close := newRelationsTable(t, dbType)
+		defer close()
+
+		// Insert some relations
+		for _, child := range []string{"b", "c", "d"} {
+			if err := tab.InsertRelation(ctx, nil, roomID, "a", child, childType, relType); err != nil {
+				t.Fatal(err)
+			}
+		}
+
+		// Check the max position, we've inserted three things so it
+		// should be 3
+		if max, err := tab.SelectMaxRelationID(ctx, nil); err != nil {
+			t.Fatal(err)
+		} else if max != 3 {
+			t.Fatalf("max position should have been 3 but got %d", max)
+		}
+
+		// Query some ranges for "a"
+		for r, expected := range map[types.Range][]types.RelationEntry{
+			{From: 0, To: 10, Backwards: false}: {
+				{Position: 1, EventID: "b"},
+				{Position: 2, EventID: "c"},
+				{Position: 3, EventID: "d"},
+			},
+			{From: 1, To: 2, Backwards: false}: {
+				{Position: 2, EventID: "c"},
+			},
+			{From: 1, To: 3, Backwards: false}: {
+				{Position: 2, EventID: "c"},
+				{Position: 3, EventID: "d"},
+			},
+			{From: 10, To: 0, Backwards: true}: {
+				{Position: 3, EventID: "d"},
+				{Position: 2, EventID: "c"},
+				{Position: 1, EventID: "b"},
+			},
+			{From: 3, To: 1, Backwards: true}: {
+				{Position: 2, EventID: "c"},
+				{Position: 1, EventID: "b"},
+			},
+		} {
+			compareRelationsToExpected(t, tab, r, expected)
+		}
+
+		// Now delete one of the relations
+		if err := tab.DeleteRelation(ctx, nil, roomID, "c"); err != nil {
+			t.Fatal(err)
+		}
+
+		// Query some more ranges for "a"
+		for r, expected := range map[types.Range][]types.RelationEntry{
+			{From: 0, To: 10, Backwards: false}: {
+				{Position: 1, EventID: "b"},
+				{Position: 3, EventID: "d"},
+			},
+			{From: 1, To: 2, Backwards: false}: {},
+			{From: 1, To: 3, Backwards: false}: {
+				{Position: 3, EventID: "d"},
+			},
+			{From: 10, To: 0, Backwards: true}: {
+				{Position: 3, EventID: "d"},
+				{Position: 1, EventID: "b"},
+			},
+			{From: 3, To: 1, Backwards: true}: {
+				{Position: 1, EventID: "b"},
+			},
+		} {
+			compareRelationsToExpected(t, tab, r, expected)
+		}
+
+		// Insert some new relations
+		for _, child := range []string{"e", "f", "g", "h"} {
+			if err := tab.InsertRelation(ctx, nil, roomID, "a", child, childType, relType); err != nil {
+				t.Fatal(err)
+			}
+		}
+
+		// Check the max position, we've inserted four things so it
+		// should now be 7
+		if max, err := tab.SelectMaxRelationID(ctx, nil); err != nil {
+			t.Fatal(err)
+		} else if max != 7 {
+			t.Fatalf("max position should have been 3 but got %d", max)
+		}
+
+		// Query last set of ranges for "a"
+		for r, expected := range map[types.Range][]types.RelationEntry{
+			{From: 0, To: 10, Backwards: false}: {
+				{Position: 1, EventID: "b"},
+				{Position: 3, EventID: "d"},
+				{Position: 4, EventID: "e"},
+				{Position: 5, EventID: "f"},
+				{Position: 6, EventID: "g"},
+				{Position: 7, EventID: "h"},
+			},
+			{From: 1, To: 2, Backwards: false}: {},
+			{From: 1, To: 3, Backwards: false}: {
+				{Position: 3, EventID: "d"},
+			},
+			{From: 10, To: 0, Backwards: true}: {
+				{Position: 7, EventID: "h"},
+				{Position: 6, EventID: "g"},
+				{Position: 5, EventID: "f"},
+				{Position: 4, EventID: "e"},
+				{Position: 3, EventID: "d"},
+				{Position: 1, EventID: "b"},
+			},
+			{From: 6, To: 3, Backwards: true}: {
+				{Position: 5, EventID: "f"},
+				{Position: 4, EventID: "e"},
+				{Position: 3, EventID: "d"},
+			},
+		} {
+			compareRelationsToExpected(t, tab, r, expected)
+		}
+	})
+}