Convert event_types table

roomserver/storage/postgres/event_types_table.go

@@ -22,6 +22,7 @@ import (
 	"github.com/matrix-org/dendrite/internal"
 
 	"github.com/lib/pq"
+	"github.com/matrix-org/dendrite/roomserver/storage/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 )
 
@@ -98,36 +99,37 @@ type eventTypeStatements struct {
 	bulkSelectEventTypeNIDStmt *sql.Stmt
 }
 
-func (s *eventTypeStatements) prepare(db *sql.DB) (err error) {
+func NewPostgresEventTypesTable(db *sql.DB) (tables.EventTypes, error) {
-	_, err = db.Exec(eventTypesSchema)
+	s := &eventTypeStatements{}
+	_, err := db.Exec(eventTypesSchema)
 	if err != nil {
-		return
+		return nil, err
 	}
 
-	return statementList{
+	return s, statementList{
 		{&s.insertEventTypeNIDStmt, insertEventTypeNIDSQL},
 		{&s.selectEventTypeNIDStmt, selectEventTypeNIDSQL},
 		{&s.bulkSelectEventTypeNIDStmt, bulkSelectEventTypeNIDSQL},
 	}.prepare(db)
 }
 
-func (s *eventTypeStatements) insertEventTypeNID(
+func (s *eventTypeStatements) InsertEventTypeNID(
-	ctx context.Context, eventType string,
+	ctx context.Context, txn *sql.Tx, eventType string,
 ) (types.EventTypeNID, error) {
 	var eventTypeNID int64
-	err := s.insertEventTypeNIDStmt.QueryRowContext(ctx, eventType).Scan(&eventTypeNID)
+	err := txn.Stmt(s.insertEventTypeNIDStmt).QueryRowContext(ctx, eventType).Scan(&eventTypeNID)
 	return types.EventTypeNID(eventTypeNID), err
 }
 
-func (s *eventTypeStatements) selectEventTypeNID(
+func (s *eventTypeStatements) SelectEventTypeNID(
-	ctx context.Context, eventType string,
+	ctx context.Context, txn *sql.Tx, eventType string,
 ) (types.EventTypeNID, error) {
 	var eventTypeNID int64
-	err := s.selectEventTypeNIDStmt.QueryRowContext(ctx, eventType).Scan(&eventTypeNID)
+	err := txn.Stmt(s.selectEventTypeNIDStmt).QueryRowContext(ctx, eventType).Scan(&eventTypeNID)
 	return types.EventTypeNID(eventTypeNID), err
 }
 
-func (s *eventTypeStatements) bulkSelectEventTypeNID(
+func (s *eventTypeStatements) BulkSelectEventTypeNID(
 	ctx context.Context, eventTypes []string,
 ) (map[string]types.EventTypeNID, error) {
 	rows, err := s.bulkSelectEventTypeNIDStmt.QueryContext(ctx, pq.StringArray(eventTypes))

roomserver/storage/postgres/sql.go

@@ -38,7 +38,6 @@ func (s *statements) prepare(db *sql.DB) error {
 	var err error
 
 	for _, prepare := range []func(db *sql.DB) error{
-		s.eventTypeStatements.prepare,
 		s.roomStatements.prepare,
 		s.eventStatements.prepare,
 		s.eventJSONStatements.prepare,

roomserver/storage/postgres/storage.go

@@ -36,6 +36,7 @@ import (
 type Database struct {
 	shared.Database
 	statements     statements
+	eventTypes     tables.EventTypes
 	eventStateKeys tables.EventStateKeys
 	db             *sql.DB
 }
@@ -54,7 +55,12 @@ func Open(dataSourceName string, dbProperties internal.DbProperties) (*Database,
 	if err != nil {
 		return nil, err
 	}
+	d.eventTypes, err = NewPostgresEventTypesTable(d.db)
+	if err != nil {
+		return nil, err
+	}
 	d.Database = shared.Database{
+		EventTypesTable:     d.eventTypes,
 		EventStateKeysTable: d.eventStateKeys,
 	}
 	return &d, nil
@@ -191,17 +197,20 @@ func (d *Database) assignRoomNID(
 
 func (d *Database) assignEventTypeNID(
 	ctx context.Context, eventType string,
-) (types.EventTypeNID, error) {
+) (eventTypeNID types.EventTypeNID, err error) {
-	// Check if we already have a numeric ID in the database.
+	err = internal.WithTransaction(d.db, func(txn *sql.Tx) error {
-	eventTypeNID, err := d.statements.selectEventTypeNID(ctx, eventType)
+		// Check if we already have a numeric ID in the database.
-	if err == sql.ErrNoRows {
+		eventTypeNID, err = d.eventTypes.SelectEventTypeNID(ctx, txn, eventType)
-		// We don't have a numeric ID so insert one into the database.
-		eventTypeNID, err = d.statements.insertEventTypeNID(ctx, eventType)
 		if err == sql.ErrNoRows {
-			// We raced with another insert so run the select again.
+			// We don't have a numeric ID so insert one into the database.
-			eventTypeNID, err = d.statements.selectEventTypeNID(ctx, eventType)
+			eventTypeNID, err = d.eventTypes.InsertEventTypeNID(ctx, txn, eventType)
+			if err == sql.ErrNoRows {
+				// We raced with another insert so run the select again.
+				eventTypeNID, err = d.eventTypes.SelectEventTypeNID(ctx, txn, eventType)
+			}
 		}
-	}
+		return err
+	})
 	return eventTypeNID, err
 }
 
@@ -228,13 +237,6 @@ func (d *Database) StateEntriesForEventIDs(
 	return d.statements.bulkSelectStateEventByID(ctx, eventIDs)
 }
 
-// EventTypeNIDs implements state.RoomStateDatabase
-func (d *Database) EventTypeNIDs(
-	ctx context.Context, eventTypes []string,
-) (map[string]types.EventTypeNID, error) {
-	return d.statements.bulkSelectEventTypeNID(ctx, eventTypes)
-}
-
 // EventNIDs implements query.RoomserverQueryAPIDatabase
 func (d *Database) EventNIDs(
 	ctx context.Context, eventIDs []string,

roomserver/storage/shared/storage.go

@@ -8,9 +8,17 @@ import (
 )
 
 type Database struct {
+	EventTypesTable     tables.EventTypes
 	EventStateKeysTable tables.EventStateKeys
 }
 
+// EventTypeNIDs implements state.RoomStateDatabase
+func (d *Database) EventTypeNIDs(
+	ctx context.Context, eventTypes []string,
+) (map[string]types.EventTypeNID, error) {
+	return d.EventTypesTable.BulkSelectEventTypeNID(ctx, eventTypes)
+}
+
 // EventStateKeys implements query.RoomserverQueryAPIDatabase
 func (d *Database) EventStateKeys(
 	ctx context.Context, eventStateKeyNIDs []types.EventStateKeyNID,

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/tables"
 	"github.com/matrix-org/dendrite/roomserver/types"
 )
 
@@ -81,14 +82,15 @@ type eventTypeStatements struct {
 	bulkSelectEventTypeNIDStmt   *sql.Stmt
 }
 
-func (s *eventTypeStatements) prepare(db *sql.DB) (err error) {
+func NewSqliteEventTypesTable(db *sql.DB) (tables.EventTypes, error) {
+	s := &eventTypeStatements{}
 	s.db = db
-	_, err = db.Exec(eventTypesSchema)
+	_, err := db.Exec(eventTypesSchema)
 	if err != nil {
-		return
+		return nil, err
 	}
 
-	return statementList{
+	return s, statementList{
 		{&s.insertEventTypeNIDStmt, insertEventTypeNIDSQL},
 		{&s.insertEventTypeNIDResultStmt, insertEventTypeNIDResultSQL},
 		{&s.selectEventTypeNIDStmt, selectEventTypeNIDSQL},
@@ -96,7 +98,7 @@ func (s *eventTypeStatements) prepare(db *sql.DB) (err error) {
 	}.prepare(db)
 }
 
-func (s *eventTypeStatements) insertEventTypeNID(
+func (s *eventTypeStatements) InsertEventTypeNID(
 	ctx context.Context, tx *sql.Tx, eventType string,
 ) (types.EventTypeNID, error) {
 	var eventTypeNID int64
@@ -109,7 +111,7 @@ func (s *eventTypeStatements) insertEventTypeNID(
 	return types.EventTypeNID(eventTypeNID), err
 }
 
-func (s *eventTypeStatements) selectEventTypeNID(
+func (s *eventTypeStatements) SelectEventTypeNID(
 	ctx context.Context, tx *sql.Tx, eventType string,
 ) (types.EventTypeNID, error) {
 	var eventTypeNID int64
@@ -118,8 +120,8 @@ func (s *eventTypeStatements) selectEventTypeNID(
 	return types.EventTypeNID(eventTypeNID), err
 }
 
-func (s *eventTypeStatements) bulkSelectEventTypeNID(
+func (s *eventTypeStatements) BulkSelectEventTypeNID(
-	ctx context.Context, tx *sql.Tx, eventTypes []string,
+	ctx context.Context, eventTypes []string,
 ) (map[string]types.EventTypeNID, error) {
 	///////////////
 	iEventTypes := make([]interface{}, len(eventTypes))
@@ -133,8 +135,7 @@ func (s *eventTypeStatements) bulkSelectEventTypeNID(
 	}
 	///////////////
 
-	selectStmt := internal.TxStmt(tx, selectPrep)
+	rows, err := selectPrep.QueryContext(ctx, iEventTypes...)
-	rows, err := selectStmt.QueryContext(ctx, iEventTypes...)
 	if err != nil {
 		return nil, err
 	}

roomserver/storage/sqlite3/sql.go

@@ -38,7 +38,6 @@ func (s *statements) prepare(db *sql.DB) error {
 	var err error
 
 	for _, prepare := range []func(db *sql.DB) error{
-		s.eventTypeStatements.prepare,
 		s.roomStatements.prepare,
 		s.eventStatements.prepare,
 		s.eventJSONStatements.prepare,

roomserver/storage/sqlite3/storage.go

@@ -37,6 +37,7 @@ import (
 type Database struct {
 	shared.Database
 	statements     statements
+	eventTypes     tables.EventTypes
 	eventStateKeys tables.EventStateKeys
 	db             *sql.DB
 }
@@ -71,10 +72,18 @@ func Open(dataSourceName string) (*Database, error) {
 		return nil, err
 	}
 	d.eventStateKeys, err = NewSqliteEventStateKeysTable(d.db)
+	if err != nil {
+		return nil, err
+	}
+	d.eventTypes, err = NewSqliteEventTypesTable(d.db)
+	if err != nil {
+		return nil, err
+	}
 	d.Database = shared.Database{
+		EventTypesTable:     d.eventTypes,
 		EventStateKeysTable: d.eventStateKeys,
 	}
-	return &d, err
+	return &d, nil
 }
 
 // StoreEvent implements input.EventDatabase
@@ -218,13 +227,13 @@ func (d *Database) assignEventTypeNID(
 	ctx context.Context, txn *sql.Tx, eventType string,
 ) (eventTypeNID types.EventTypeNID, err error) {
 	// Check if we already have a numeric ID in the database.
-	eventTypeNID, err = d.statements.selectEventTypeNID(ctx, txn, eventType)
+	eventTypeNID, err = d.eventTypes.SelectEventTypeNID(ctx, txn, eventType)
 	if err == sql.ErrNoRows {
 		// We don't have a numeric ID so insert one into the database.
-		eventTypeNID, err = d.statements.insertEventTypeNID(ctx, txn, eventType)
+		eventTypeNID, err = d.eventTypes.InsertEventTypeNID(ctx, txn, eventType)
 		if err == sql.ErrNoRows {
 			// We raced with another insert so run the select again.
-			eventTypeNID, err = d.statements.selectEventTypeNID(ctx, txn, eventType)
+			eventTypeNID, err = d.eventTypes.SelectEventTypeNID(ctx, txn, eventType)
 		}
 	}
 	return
@@ -257,17 +266,6 @@ func (d *Database) StateEntriesForEventIDs(
 	return
 }
 
-// EventTypeNIDs implements state.RoomStateDatabase
-func (d *Database) EventTypeNIDs(
-	ctx context.Context, eventTypes []string,
-) (etnids map[string]types.EventTypeNID, err error) {
-	err = internal.WithTransaction(d.db, func(txn *sql.Tx) error {
-		etnids, err = d.statements.bulkSelectEventTypeNID(ctx, txn, eventTypes)
-		return err
-	})
-	return
-}
-
 // EventNIDs implements query.RoomserverQueryAPIDatabase
 func (d *Database) EventNIDs(
 	ctx context.Context, eventIDs []string,

roomserver/storage/tables/interface.go

@@ -7,6 +7,12 @@ import (
 	"github.com/matrix-org/dendrite/roomserver/types"
 )
 
+type EventTypes interface {
+	InsertEventTypeNID(ctx context.Context, tx *sql.Tx, eventType string) (types.EventTypeNID, error)
+	SelectEventTypeNID(ctx context.Context, tx *sql.Tx, eventType string) (types.EventTypeNID, error)
+	BulkSelectEventTypeNID(ctx context.Context, eventTypes []string) (map[string]types.EventTypeNID, error)
+}
+
 type EventStateKeys interface {
 	InsertEventStateKeyNID(ctx context.Context, txn *sql.Tx, eventStateKey string) (types.EventStateKeyNID, error)
 	SelectEventStateKeyNID(ctx context.Context, txn *sql.Tx, eventStateKey string) (types.EventStateKeyNID, error)