Convert remaining roomserver tables (#1065)

* Convert invites table

* Convert membership table

* Factor out remaining functions except for *Updater structs

* Remove 'implements' comments from long-forgotten interfaces. Move those comments to storage.Database

15 files changed, 100 insertions, 225 deletions

diff --git a/roomserver/storage/sqlite3/event_json_table.go b/roomserver/storage/sqlite3/event_json_table.go
index 34b067cb..7ff4c1d4 100644
--- a/roomserver/storage/sqlite3/event_json_table.go
+++ b/roomserver/storage/sqlite3/event_json_table.go
@@ -21,6 +21,7 @@ import (
 	"strings"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 )
@@ -59,10 +60,10 @@ func NewSqliteEventJSONTable(db *sql.DB) (tables.EventJSON, error) {
 	if err != nil {
 		return nil, err
 	}
-	return s, statementList{
+	return s, shared.StatementList{
 		{&s.insertEventJSONStmt, insertEventJSONSQL},
 		{&s.bulkSelectEventJSONStmt, bulkSelectEventJSONSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
 func (s *eventJSONStatements) InsertEventJSON(
diff --git a/roomserver/storage/sqlite3/event_state_keys_table.go b/roomserver/storage/sqlite3/event_state_keys_table.go
index 0d3d323f..2d2c04d2 100644
--- a/roomserver/storage/sqlite3/event_state_keys_table.go
+++ b/roomserver/storage/sqlite3/event_state_keys_table.go
@@ -21,6 +21,7 @@ import (
 	"strings"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 )
@@ -75,12 +76,12 @@ func NewSqliteEventStateKeysTable(db *sql.DB) (tables.EventStateKeys, error) {
 	if err != nil {
 		return nil, err
 	}
-	return s, statementList{
+	return s, shared.StatementList{
 		{&s.insertEventStateKeyNIDStmt, insertEventStateKeyNIDSQL},
 		{&s.selectEventStateKeyNIDStmt, selectEventStateKeyNIDSQL},
 		{&s.bulkSelectEventStateKeyNIDStmt, bulkSelectEventStateKeyNIDSQL},
 		{&s.bulkSelectEventStateKeyStmt, bulkSelectEventStateKeySQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
 func (s *eventStateKeyStatements) InsertEventStateKeyNID(
@@ -89,7 +90,7 @@ func (s *eventStateKeyStatements) InsertEventStateKeyNID(
 	var eventStateKeyNID int64
 	var err error
 	var res sql.Result
-	insertStmt := txn.Stmt(s.insertEventStateKeyNIDStmt)
+	insertStmt := internal.TxStmt(txn, s.insertEventStateKeyNIDStmt)
 	if res, err = insertStmt.ExecContext(ctx, eventStateKey); err == nil {
 		eventStateKeyNID, err = res.LastInsertId()
 	}
@@ -100,7 +101,7 @@ func (s *eventStateKeyStatements) SelectEventStateKeyNID(
 	ctx context.Context, txn *sql.Tx, eventStateKey string,
 ) (types.EventStateKeyNID, error) {
 	var eventStateKeyNID int64
-	stmt := txn.Stmt(s.selectEventStateKeyNIDStmt)
+	stmt := internal.TxStmt(txn, s.selectEventStateKeyNIDStmt)
 	err := stmt.QueryRowContext(ctx, eventStateKey).Scan(&eventStateKeyNID)
 	return types.EventStateKeyNID(eventStateKeyNID), err
 }
diff --git a/roomserver/storage/sqlite3/event_types_table.go b/roomserver/storage/sqlite3/event_types_table.go
index d47be545..6d229bbd 100644
--- a/roomserver/storage/sqlite3/event_types_table.go
+++ b/roomserver/storage/sqlite3/event_types_table.go
@@ -21,6 +21,7 @@ import (
 	"strings"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 )
@@ -90,12 +91,12 @@ func NewSqliteEventTypesTable(db *sql.DB) (tables.EventTypes, error) {
 		return nil, err
 	}
 
-	return s, statementList{
+	return s, shared.StatementList{
 		{&s.insertEventTypeNIDStmt, insertEventTypeNIDSQL},
 		{&s.insertEventTypeNIDResultStmt, insertEventTypeNIDResultSQL},
 		{&s.selectEventTypeNIDStmt, selectEventTypeNIDSQL},
 		{&s.bulkSelectEventTypeNIDStmt, bulkSelectEventTypeNIDSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
 func (s *eventTypeStatements) InsertEventTypeNID(
diff --git a/roomserver/storage/sqlite3/events_table.go b/roomserver/storage/sqlite3/events_table.go
index 247faa68..491399ce 100644
--- a/roomserver/storage/sqlite3/events_table.go
+++ b/roomserver/storage/sqlite3/events_table.go
@@ -23,6 +23,7 @@ import (
 	"strings"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -120,7 +121,7 @@ func NewSqliteEventsTable(db *sql.DB) (tables.Events, error) {
 		return nil, err
 	}
 
-	return s, statementList{
+	return s, shared.StatementList{
 		{&s.insertEventStmt, insertEventSQL},
 		{&s.selectEventStmt, selectEventSQL},
 		{&s.bulkSelectStateEventByIDStmt, bulkSelectStateEventByIDSQL},
@@ -134,7 +135,7 @@ func NewSqliteEventsTable(db *sql.DB) (tables.Events, error) {
 		{&s.bulkSelectEventIDStmt, bulkSelectEventIDSQL},
 		{&s.bulkSelectEventNIDStmt, bulkSelectEventNIDSQL},
 		{&s.selectRoomNIDForEventNIDStmt, selectRoomNIDForEventNIDSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
 func (s *eventStatements) InsertEvent(
diff --git a/roomserver/storage/sqlite3/invite_table.go b/roomserver/storage/sqlite3/invite_table.go
index a42d18a7..fbe2b072 100644
--- a/roomserver/storage/sqlite3/invite_table.go
+++ b/roomserver/storage/sqlite3/invite_table.go
@@ -20,6 +20,8 @@ import (
 	"database/sql"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
+	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 )
 
@@ -66,21 +68,22 @@ type inviteStatements struct {
 	selectInvitesAboutToRetireStmt      *sql.Stmt
 }
 
-func (s *inviteStatements) prepare(db *sql.DB) (err error) {
-	_, err = db.Exec(inviteSchema)
+func NewSqliteInvitesTable(db *sql.DB) (tables.Invites, error) {
+	s := &inviteStatements{}
+	_, err := db.Exec(inviteSchema)
 	if err != nil {
-		return
+		return nil, err
 	}
 
-	return statementList{
+	return s, shared.StatementList{
 		{&s.insertInviteEventStmt, insertInviteEventSQL},
 		{&s.selectInviteActiveForUserInRoomStmt, selectInviteActiveForUserInRoomSQL},
 		{&s.updateInviteRetiredStmt, updateInviteRetiredSQL},
 		{&s.selectInvitesAboutToRetireStmt, selectInvitesAboutToRetireSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
-func (s *inviteStatements) insertInviteEvent(
+func (s *inviteStatements) InsertInviteEvent(
 	ctx context.Context,
 	txn *sql.Tx, inviteEventID string, roomNID types.RoomNID,
 	targetUserNID, senderUserNID types.EventStateKeyNID,
@@ -101,7 +104,7 @@ func (s *inviteStatements) insertInviteEvent(
 	return count != 0, nil
 }
 
-func (s *inviteStatements) updateInviteRetired(
+func (s *inviteStatements) UpdateInviteRetired(
 	ctx context.Context,
 	txn *sql.Tx, roomNID types.RoomNID, targetUserNID types.EventStateKeyNID,
 ) (eventIDs []string, err error) {
@@ -127,7 +130,7 @@ func (s *inviteStatements) updateInviteRetired(
 }
 
 // selectInviteActiveForUserInRoom returns a list of sender state key NIDs
-func (s *inviteStatements) selectInviteActiveForUserInRoom(
+func (s *inviteStatements) SelectInviteActiveForUserInRoom(
 	ctx context.Context,
 	targetUserNID types.EventStateKeyNID, roomNID types.RoomNID,
 ) ([]types.EventStateKeyNID, error) {
diff --git a/roomserver/storage/sqlite3/membership_table.go b/roomserver/storage/sqlite3/membership_table.go
index 34108af4..5f3076c5 100644
--- a/roomserver/storage/sqlite3/membership_table.go
+++ b/roomserver/storage/sqlite3/membership_table.go
@@ -20,17 +20,11 @@ import (
 	"database/sql"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
+	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 )
 
-type membershipState int64
-
-const (
-	membershipStateLeaveOrBan membershipState = 1
-	membershipStateInvite     membershipState = 2
-	membershipStateJoin       membershipState = 3
-)
-
 const membershipSchema = `
 	CREATE TABLE IF NOT EXISTS roomserver_membership (
 		room_nid INTEGER NOT NULL,
@@ -91,13 +85,14 @@ type membershipStatements struct {
 	updateMembershipStmt                            *sql.Stmt
 }
 
-func (s *membershipStatements) prepare(db *sql.DB) (err error) {
-	_, err = db.Exec(membershipSchema)
+func NewSqliteMembershipTable(db *sql.DB) (tables.Membership, error) {
+	s := &membershipStatements{}
+	_, err := db.Exec(membershipSchema)
 	if err != nil {
-		return
+		return nil, err
 	}
 
-	return statementList{
+	return s, shared.StatementList{
 		{&s.insertMembershipStmt, insertMembershipSQL},
 		{&s.selectMembershipForUpdateStmt, selectMembershipForUpdateSQL},
 		{&s.selectMembershipFromRoomAndTargetStmt, selectMembershipFromRoomAndTargetSQL},
@@ -106,10 +101,10 @@ func (s *membershipStatements) prepare(db *sql.DB) (err error) {
 		{&s.selectMembershipsFromRoomStmt, selectMembershipsFromRoomSQL},
 		{&s.selectLocalMembershipsFromRoomStmt, selectLocalMembershipsFromRoomSQL},
 		{&s.updateMembershipStmt, updateMembershipSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
-func (s *membershipStatements) insertMembership(
+func (s *membershipStatements) InsertMembership(
 	ctx context.Context, txn *sql.Tx,
 	roomNID types.RoomNID, targetUserNID types.EventStateKeyNID,
 	localTarget bool,
@@ -119,10 +114,10 @@ func (s *membershipStatements) insertMembership(
 	return err
 }
 
-func (s *membershipStatements) selectMembershipForUpdate(
+func (s *membershipStatements) SelectMembershipForUpdate(
 	ctx context.Context, txn *sql.Tx,
 	roomNID types.RoomNID, targetUserNID types.EventStateKeyNID,
-) (membership membershipState, err error) {
+) (membership tables.MembershipState, err error) {
 	stmt := internal.TxStmt(txn, s.selectMembershipForUpdateStmt)
 	err = stmt.QueryRowContext(
 		ctx, roomNID, targetUserNID,
@@ -130,26 +125,25 @@ func (s *membershipStatements) selectMembershipForUpdate(
 	return
 }
 
-func (s *membershipStatements) selectMembershipFromRoomAndTarget(
-	ctx context.Context, txn *sql.Tx,
+func (s *membershipStatements) SelectMembershipFromRoomAndTarget(
+	ctx context.Context,
 	roomNID types.RoomNID, targetUserNID types.EventStateKeyNID,
-) (eventNID types.EventNID, membership membershipState, err error) {
-	selectStmt := internal.TxStmt(txn, s.selectMembershipFromRoomAndTargetStmt)
-	err = selectStmt.QueryRowContext(
+) (eventNID types.EventNID, membership tables.MembershipState, err error) {
+	err = s.selectMembershipFromRoomAndTargetStmt.QueryRowContext(
 		ctx, roomNID, targetUserNID,
 	).Scan(&membership, &eventNID)
 	return
 }
 
-func (s *membershipStatements) selectMembershipsFromRoom(
-	ctx context.Context, txn *sql.Tx,
+func (s *membershipStatements) SelectMembershipsFromRoom(
+	ctx context.Context,
 	roomNID types.RoomNID, localOnly bool,
 ) (eventNIDs []types.EventNID, err error) {
 	var selectStmt *sql.Stmt
 	if localOnly {
-		selectStmt = internal.TxStmt(txn, s.selectLocalMembershipsFromRoomStmt)
+		selectStmt = s.selectLocalMembershipsFromRoomStmt
 	} else {
-		selectStmt = internal.TxStmt(txn, s.selectMembershipsFromRoomStmt)
+		selectStmt = s.selectMembershipsFromRoomStmt
 	}
 	rows, err := selectStmt.QueryContext(ctx, roomNID)
 	if err != nil {
@@ -167,15 +161,15 @@ func (s *membershipStatements) selectMembershipsFromRoom(
 	return
 }
 
-func (s *membershipStatements) selectMembershipsFromRoomAndMembership(
-	ctx context.Context, txn *sql.Tx,
-	roomNID types.RoomNID, membership membershipState, localOnly bool,
+func (s *membershipStatements) SelectMembershipsFromRoomAndMembership(
+	ctx context.Context,
+	roomNID types.RoomNID, membership tables.MembershipState, localOnly bool,
 ) (eventNIDs []types.EventNID, err error) {
 	var stmt *sql.Stmt
 	if localOnly {
-		stmt = internal.TxStmt(txn, s.selectLocalMembershipsFromRoomAndMembershipStmt)
+		stmt = s.selectLocalMembershipsFromRoomAndMembershipStmt
 	} else {
-		stmt = internal.TxStmt(txn, s.selectMembershipsFromRoomAndMembershipStmt)
+		stmt = s.selectMembershipsFromRoomAndMembershipStmt
 	}
 	rows, err := stmt.QueryContext(ctx, roomNID, membership)
 	if err != nil {
@@ -193,10 +187,10 @@ func (s *membershipStatements) selectMembershipsFromRoomAndMembership(
 	return
 }
 
-func (s *membershipStatements) updateMembership(
+func (s *membershipStatements) UpdateMembership(
 	ctx context.Context, txn *sql.Tx,
 	roomNID types.RoomNID, targetUserNID types.EventStateKeyNID,
-	senderUserNID types.EventStateKeyNID, membership membershipState,
+	senderUserNID types.EventStateKeyNID, membership tables.MembershipState,
 	eventNID types.EventNID,
 ) error {
 	stmt := internal.TxStmt(txn, s.updateMembershipStmt)
diff --git a/roomserver/storage/sqlite3/prepare.go b/roomserver/storage/sqlite3/prepare.go
deleted file mode 100644
index 482dfa2b..00000000
--- a/roomserver/storage/sqlite3/prepare.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2017-2018 New Vector Ltd
-// Copyright 2019-2020 The Matrix.org Foundation C.I.C.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package sqlite3
-
-import (
-	"database/sql"
-)
-
-// a statementList is a list of SQL statements to prepare and a pointer to where to store the resulting prepared statement.
-type statementList []struct {
-	statement **sql.Stmt
-	sql       string
-}
-
-// prepare the SQL for each statement in the list and assign the result to the prepared statement.
-func (s statementList) prepare(db *sql.DB) (err error) {
-	for _, statement := range s {
-		if *statement.statement, err = db.Prepare(statement.sql); err != nil {
-			return
-		}
-	}
-	return
-}
diff --git a/roomserver/storage/sqlite3/previous_events_table.go b/roomserver/storage/sqlite3/previous_events_table.go
index 6b758ccc..2b187bba 100644
--- a/roomserver/storage/sqlite3/previous_events_table.go
+++ b/roomserver/storage/sqlite3/previous_events_table.go
@@ -20,6 +20,7 @@ import (
 	"database/sql"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 )
@@ -63,10 +64,10 @@ func NewSqlitePrevEventsTable(db *sql.DB) (tables.PreviousEvents, error) {
 		return nil, err
 	}
 
-	return s, statementList{
+	return s, shared.StatementList{
 		{&s.insertPreviousEventStmt, insertPreviousEventSQL},
 		{&s.selectPreviousEventExistsStmt, selectPreviousEventExistsSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
 func (s *previousEventStatements) InsertPreviousEvent(
diff --git a/roomserver/storage/sqlite3/room_aliases_table.go b/roomserver/storage/sqlite3/room_aliases_table.go
index 686391f6..da5f9161 100644
--- a/roomserver/storage/sqlite3/room_aliases_table.go
+++ b/roomserver/storage/sqlite3/room_aliases_table.go
@@ -20,6 +20,7 @@ import (
 	"database/sql"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 )
 
@@ -67,13 +68,13 @@ func NewSqliteRoomAliasesTable(db *sql.DB) (tables.RoomAliases, error) {
 	if err != nil {
 		return nil, err
 	}
-	return s, statementList{
+	return s, shared.StatementList{
 		{&s.insertRoomAliasStmt, insertRoomAliasSQL},
 		{&s.selectRoomIDFromAliasStmt, selectRoomIDFromAliasSQL},
 		{&s.selectAliasesFromRoomIDStmt, selectAliasesFromRoomIDSQL},
 		{&s.selectCreatorIDFromAliasStmt, selectCreatorIDFromAliasSQL},
 		{&s.deleteRoomAliasStmt, deleteRoomAliasSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
 func (s *roomAliasesStatements) InsertRoomAlias(
diff --git a/roomserver/storage/sqlite3/rooms_table.go b/roomserver/storage/sqlite3/rooms_table.go
index 75b8fec9..d22fceb3 100644
--- a/roomserver/storage/sqlite3/rooms_table.go
+++ b/roomserver/storage/sqlite3/rooms_table.go
@@ -22,6 +22,7 @@ import (
 	"errors"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -78,7 +79,7 @@ func NewSqliteRoomsTable(db *sql.DB) (tables.Rooms, error) {
 	if err != nil {
 		return nil, err
 	}
-	return s, statementList{
+	return s, shared.StatementList{
 		{&s.insertRoomNIDStmt, insertRoomNIDSQL},
 		{&s.selectRoomNIDStmt, selectRoomNIDSQL},
 		{&s.selectLatestEventNIDsStmt, selectLatestEventNIDsSQL},
@@ -86,7 +87,7 @@ func NewSqliteRoomsTable(db *sql.DB) (tables.Rooms, error) {
 		{&s.updateLatestEventNIDsStmt, updateLatestEventNIDsSQL},
 		{&s.selectRoomVersionForRoomIDStmt, selectRoomVersionForRoomIDSQL},
 		{&s.selectRoomVersionForRoomNIDStmt, selectRoomVersionForRoomNIDSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
 func (s *roomStatements) InsertRoomNID(
diff --git a/roomserver/storage/sqlite3/sql.go b/roomserver/storage/sqlite3/sql.go
deleted file mode 100644
index df994d50..00000000
--- a/roomserver/storage/sqlite3/sql.go
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2017-2018 New Vector Ltd
-// Copyright 2019-2020 The Matrix.org Foundation C.I.C.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package sqlite3
-
-import (
-	"database/sql"
-)
-
-type statements struct {
-	eventTypeStatements
-	eventStateKeyStatements
-	roomStatements
-	eventStatements
-	eventJSONStatements
-	stateSnapshotStatements
-	stateBlockStatements
-	previousEventStatements
-	roomAliasesStatements
-	inviteStatements
-	membershipStatements
-	transactionStatements
-}
-
-func (s *statements) prepare(db *sql.DB) error {
-	var err error
-
-	for _, prepare := range []func(db *sql.DB) error{
-		s.inviteStatements.prepare,
-		s.membershipStatements.prepare,
-	} {
-		if err = prepare(db); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
diff --git a/roomserver/storage/sqlite3/state_block_table.go b/roomserver/storage/sqlite3/state_block_table.go
index e3ca0b3c..399fdbf6 100644
--- a/roomserver/storage/sqlite3/state_block_table.go
+++ b/roomserver/storage/sqlite3/state_block_table.go
@@ -23,6 +23,7 @@ import (
 	"strings"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/util"
@@ -86,12 +87,12 @@ func NewSqliteStateBlockTable(db *sql.DB) (tables.StateBlock, error) {
 		return nil, err
 	}
 
-	return s, statementList{
+	return s, shared.StatementList{
 		{&s.insertStateDataStmt, insertStateDataSQL},
 		{&s.selectNextStateBlockNIDStmt, selectNextStateBlockNIDSQL},
 		{&s.bulkSelectStateBlockEntriesStmt, bulkSelectStateBlockEntriesSQL},
 		{&s.bulkSelectFilteredStateBlockEntriesStmt, bulkSelectFilteredStateBlockEntriesSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
 func (s *stateBlockStatements) BulkInsertStateData(
diff --git a/roomserver/storage/sqlite3/state_snapshot_table.go b/roomserver/storage/sqlite3/state_snapshot_table.go
index 42eae1a7..5de3f639 100644
--- a/roomserver/storage/sqlite3/state_snapshot_table.go
+++ b/roomserver/storage/sqlite3/state_snapshot_table.go
@@ -23,6 +23,7 @@ import (
 	"strings"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 )
@@ -60,10 +61,10 @@ func NewSqliteStateSnapshotTable(db *sql.DB) (tables.StateSnapshot, error) {
 		return nil, err
 	}
 
-	return s, statementList{
+	return s, shared.StatementList{
 		{&s.insertStateStmt, insertStateSQL},
 		{&s.bulkSelectStateBlockNIDsStmt, bulkSelectStateBlockNIDsSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
 func (s *stateSnapshotStatements) InsertState(
diff --git a/roomserver/storage/sqlite3/storage.go b/roomserver/storage/sqlite3/storage.go
index 16697f1b..16d89304 100644
--- a/roomserver/storage/sqlite3/storage.go
+++ b/roomserver/storage/sqlite3/storage.go
@@ -34,7 +34,6 @@ import (
 // A Database is used to store room events and stream offsets.
 type Database struct {
 	shared.Database
-	statements     statements
 	events         tables.Events
 	eventJSON      tables.EventJSON
 	eventTypes     tables.EventTypes
@@ -42,6 +41,8 @@ type Database struct {
 	rooms          tables.Rooms
 	transactions   tables.Transactions
 	prevEvents     tables.PreviousEvents
+	invites        tables.Invites
+	membership     tables.Membership
 	db             *sql.DB
 }
 
@@ -72,9 +73,7 @@ func Open(dataSourceName string) (*Database, error) {
 	// acquire the global mutex and never unlock it because it is waiting for a connection
 	// which it will never obtain.
 	d.db.SetMaxOpenConns(20)
-	if err = d.statements.prepare(d.db); err != nil {
-		return nil, err
-	}
+
 	d.eventStateKeys, err = NewSqliteEventStateKeysTable(d.db)
 	if err != nil {
 		return nil, err
@@ -115,6 +114,14 @@ func Open(dataSourceName string) (*Database, error) {
 	if err != nil {
 		return nil, err
 	}
+	d.invites, err = NewSqliteInvitesTable(d.db)
+	if err != nil {
+		return nil, err
+	}
+	d.membership, err = NewSqliteMembershipTable(d.db)
+	if err != nil {
+		return nil, err
+	}
 	d.Database = shared.Database{
 		DB:                  d.db,
 		EventsTable:         d.events,
@@ -127,6 +134,8 @@ func Open(dataSourceName string) (*Database, error) {
 		StateSnapshotTable:  stateSnapshot,
 		PrevEventsTable:     d.prevEvents,
 		RoomAliasesTable:    roomAliases,
+		InvitesTable:        d.invites,
+		MembershipTable:     d.membership,
 	}
 	return &d, nil
 }
@@ -305,15 +314,6 @@ func (u *roomRecentEventsUpdater) MembershipUpdater(targetUserNID types.EventSta
 	return
 }
 
-// GetInvitesForUser implements query.RoomserverQueryAPIDatabase
-func (d *Database) GetInvitesForUser(
-	ctx context.Context,
-	roomNID types.RoomNID,
-	targetUserNID types.EventStateKeyNID,
-) (senderUserIDs []types.EventStateKeyNID, err error) {
-	return d.statements.selectInviteActiveForUserInRoom(ctx, targetUserNID, roomNID)
-}
-
 // MembershipUpdater implements input.RoomEventDatabase
 func (d *Database) MembershipUpdater(
 	ctx context.Context, roomID, targetUserID string,
@@ -367,7 +367,7 @@ type membershipUpdater struct {
 	d             *Database
 	roomNID       types.RoomNID
 	targetUserNID types.EventStateKeyNID
-	membership    membershipState
+	membership    tables.MembershipState
 }
 
 func (d *Database) membershipUpdaterTxn(
@@ -378,11 +378,11 @@ func (d *Database) membershipUpdaterTxn(
 	targetLocal bool,
 ) (types.MembershipUpdater, error) {
 
-	if err := d.statements.insertMembership(ctx, txn, roomNID, targetUserNID, targetLocal); err != nil {
+	if err := d.membership.InsertMembership(ctx, txn, roomNID, targetUserNID, targetLocal); err != nil {
 		return nil, err
 	}
 
-	membership, err := d.statements.selectMembershipForUpdate(ctx, txn, roomNID, targetUserNID)
+	membership, err := d.membership.SelectMembershipForUpdate(ctx, txn, roomNID, targetUserNID)
 	if err != nil {
 		return nil, err
 	}
@@ -395,17 +395,17 @@ func (d *Database) membershipUpdaterTxn(
 
 // IsInvite implements types.MembershipUpdater
 func (u *membershipUpdater) IsInvite() bool {
-	return u.membership == membershipStateInvite
+	return u.membership == tables.MembershipStateInvite
 }
 
 // IsJoin implements types.MembershipUpdater
 func (u *membershipUpdater) IsJoin() bool {
-	return u.membership == membershipStateJoin
+	return u.membership == tables.MembershipStateJoin
 }
 
 // IsLeave implements types.MembershipUpdater
 func (u *membershipUpdater) IsLeave() bool {
-	return u.membership == membershipStateLeaveOrBan
+	return u.membership == tables.MembershipStateLeaveOrBan
 }
 
 // SetToInvite implements types.MembershipUpdater
@@ -415,15 +415,15 @@ func (u *membershipUpdater) SetToInvite(event gomatrixserverlib.Event) (inserted
 		if err != nil {
 			return err
 		}
-		inserted, err = u.d.statements.insertInviteEvent(
+		inserted, err = u.d.invites.InsertInviteEvent(
 			u.ctx, txn, event.EventID(), u.roomNID, u.targetUserNID, senderUserNID, event.JSON(),
 		)
 		if err != nil {
 			return err
 		}
-		if u.membership != membershipStateInvite {
-			if err = u.d.statements.updateMembership(
-				u.ctx, txn, u.roomNID, u.targetUserNID, senderUserNID, membershipStateInvite, 0,
+		if u.membership != tables.MembershipStateInvite {
+			if err = u.d.membership.UpdateMembership(
+				u.ctx, txn, u.roomNID, u.targetUserNID, senderUserNID, tables.MembershipStateInvite, 0,
 			); err != nil {
 				return err
 			}
@@ -443,7 +443,7 @@ func (u *membershipUpdater) SetToJoin(senderUserID string, eventID string, isUpd
 
 		// If this is a join event update, there is no invite to update
 		if !isUpdate {
-			inviteEventIDs, err = u.d.statements.updateInviteRetired(
+			inviteEventIDs, err = u.d.invites.UpdateInviteRetired(
 				u.ctx, txn, u.roomNID, u.targetUserNID,
 			)
 			if err != nil {
@@ -457,10 +457,10 @@ func (u *membershipUpdater) SetToJoin(senderUserID string, eventID string, isUpd
 			return err
 		}
 
-		if u.membership != membershipStateJoin || isUpdate {
-			if err = u.d.statements.updateMembership(
+		if u.membership != tables.MembershipStateJoin || isUpdate {
+			if err = u.d.membership.UpdateMembership(
 				u.ctx, txn, u.roomNID, u.targetUserNID, senderUserNID,
-				membershipStateJoin, nIDs[eventID],
+				tables.MembershipStateJoin, nIDs[eventID],
 			); err != nil {
 				return err
 			}
@@ -478,7 +478,7 @@ func (u *membershipUpdater) SetToLeave(senderUserID string, eventID string) (inv
 		if err != nil {
 			return err
 		}
-		inviteEventIDs, err = u.d.statements.updateInviteRetired(
+		inviteEventIDs, err = u.d.invites.UpdateInviteRetired(
 			u.ctx, txn, u.roomNID, u.targetUserNID,
 		)
 		if err != nil {
@@ -491,10 +491,10 @@ func (u *membershipUpdater) SetToLeave(senderUserID string, eventID string) (inv
 			return err
 		}
 
-		if u.membership != membershipStateLeaveOrBan {
-			if err = u.d.statements.updateMembership(
+		if u.membership != tables.MembershipStateLeaveOrBan {
+			if err = u.d.membership.UpdateMembership(
 				u.ctx, txn, u.roomNID, u.targetUserNID, senderUserNID,
-				membershipStateLeaveOrBan, nIDs[eventID],
+				tables.MembershipStateLeaveOrBan, nIDs[eventID],
 			); err != nil {
 				return err
 			}
@@ -504,52 +504,6 @@ func (u *membershipUpdater) SetToLeave(senderUserID string, eventID string) (inv
 	return
 }
 
-// GetMembership implements query.RoomserverQueryAPIDB
-func (d *Database) GetMembership(
-	ctx context.Context, roomNID types.RoomNID, requestSenderUserID string,
-) (membershipEventNID types.EventNID, stillInRoom bool, err error) {
-	err = internal.WithTransaction(d.db, func(txn *sql.Tx) error {
-		requestSenderUserNID, err := d.assignStateKeyNID(ctx, txn, requestSenderUserID)
-		if err != nil {
-			return err
-		}
-
-		membershipEventNID, _, err =
-			d.statements.selectMembershipFromRoomAndTarget(
-				ctx, txn, roomNID, requestSenderUserNID,
-			)
-		if err == sql.ErrNoRows {
-			// The user has never been a member of that room
-			return nil
-		}
-		if err != nil {
-			return err
-		}
-		stillInRoom = true
-		return nil
-	})
-
-	return
-}
-
-// GetMembershipEventNIDsForRoom implements query.RoomserverQueryAPIDB
-func (d *Database) GetMembershipEventNIDsForRoom(
-	ctx context.Context, roomNID types.RoomNID, joinOnly bool, localOnly bool,
-) (eventNIDs []types.EventNID, err error) {
-	err = internal.WithTransaction(d.db, func(txn *sql.Tx) error {
-		if joinOnly {
-			eventNIDs, err = d.statements.selectMembershipsFromRoomAndMembership(
-				ctx, txn, roomNID, membershipStateJoin, localOnly,
-			)
-			return nil
-		}
-
-		eventNIDs, err = d.statements.selectMembershipsFromRoom(ctx, txn, roomNID, localOnly)
-		return nil
-	})
-	return
-}
-
 type transaction struct {
 	ctx context.Context
 	txn *sql.Tx
diff --git a/roomserver/storage/sqlite3/transactions_table.go b/roomserver/storage/sqlite3/transactions_table.go
index 37ea15c0..7b489ac6 100644
--- a/roomserver/storage/sqlite3/transactions_table.go
+++ b/roomserver/storage/sqlite3/transactions_table.go
@@ -20,6 +20,7 @@ import (
 	"database/sql"
 
 	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 )
 
@@ -54,10 +55,10 @@ func NewSqliteTransactionsTable(db *sql.DB) (tables.Transactions, error) {
 		return nil, err
 	}
 
-	return s, statementList{
+	return s, shared.StatementList{
 		{&s.insertTransactionStmt, insertTransactionSQL},
 		{&s.selectTransactionEventIDStmt, selectTransactionEventIDSQL},
-	}.prepare(db)
+	}.Prepare(db)
 }
 
 func (s *transactionStatements) InsertTransaction(