Nuke fmt.println

roomserver/input/events.go

@@ -124,10 +124,8 @@ func processRoomEvent(
 	if stateAtEvent.BeforeStateSnapshotNID == 0 {
 		// We haven't calculated a state for this event yet.
 		// Lets calculate one.
-		fmt.Println("We don't have a state snapshot NID yet")
 		err = calculateAndSetState(ctx, db, input, roomNID, &stateAtEvent, event)
 		if err != nil {
-			fmt.Println("Failed to calculateAndSetState:", err)
 			return
 		}
 	}
@@ -153,7 +151,6 @@ func calculateAndSetState(
 ) error {
 	var err error
 	if input.HasState {
-		fmt.Println("We have state")
 		// We've been told what the state at the event is so we don't need to calculate it.
 		// Check that those state events are in the database and store the state.
 		var entries []types.StateEntry
@@ -165,13 +162,11 @@ func calculateAndSetState(
 			return err
 		}
 	} else {
-		fmt.Println("We don't have state")
 		// We haven't been told what the state at the event is so we need to calculate it from the prev_events
 		if stateAtEvent.BeforeStateSnapshotNID, err = state.CalculateAndStoreStateBeforeEvent(ctx, db, event, roomNID); err != nil {
 			return err
 		}
 	}
-	fmt.Println("Then set state", stateAtEvent)
 	return db.SetState(ctx, stateAtEvent.EventNID, stateAtEvent.BeforeStateSnapshotNID)
 }
 

roomserver/state/state.go

@@ -556,15 +556,11 @@ func CalculateAndStoreStateBeforeEvent(
 		prevEventIDs[i] = prevEventRefs[i].EventID
 	}
 
-	fmt.Println("Previous event IDs:", prevEventIDs)
-
 	prevStates, err := db.StateAtEventIDs(ctx, prevEventIDs)
 	if err != nil {
 		return 0, err
 	}
 
-	fmt.Println("Previous states:", prevStates)
-
 	// The state before this event will be the state after the events that came before it.
 	return CalculateAndStoreStateAfterEvents(ctx, db, roomNID, prevStates)
 }
@@ -618,7 +614,6 @@ func CalculateAndStoreStateAfterEvents(
 		// So fall through to calculateAndStoreStateAfterManyEvents
 	}
 
-	fmt.Println("Falling through to calculateAndStoreStateAfterManyEvents")
 	return calculateAndStoreStateAfterManyEvents(ctx, db, roomNID, prevStates, metrics)
 }
 

roomserver/storage/postgres/events_table.go

@@ -262,9 +262,7 @@ func (s *eventStatements) bulkSelectStateAtEventByID(
 func (s *eventStatements) updateEventState(
 	ctx context.Context, eventNID types.EventNID, stateNID types.StateSnapshotNID,
 ) error {
-	fmt.Println("updateEventState eventNID", eventNID, "stateNID", stateNID)
 	_, err := s.updateEventStateStmt.ExecContext(ctx, int64(eventNID), int64(stateNID))
-	fmt.Println("Errors?", err)
 	return err
 }
 

roomserver/storage/sqlite3/event_state_keys_table.go

@@ -18,7 +18,6 @@ package sqlite3
 import (
 	"context"
 	"database/sql"
-	"fmt"
 	"strings"
 
 	"github.com/matrix-org/dendrite/roomserver/types"
@@ -90,8 +89,6 @@ func (s *eventStateKeyStatements) insertEventStateKeyNID(
 	insertStmt := txn.Stmt(s.insertEventStateKeyNIDStmt)
 	if res, err = insertStmt.ExecContext(ctx, eventStateKey); err == nil {
 		eventStateKeyNID, err = res.LastInsertId()
-	} else {
-		fmt.Println("insertEventStateKeyNID insertStmt.ExecContext:", err)
 	}
 	return types.EventStateKeyNID(eventStateKeyNID), err
 }

roomserver/storage/sqlite3/events_table.go

@@ -153,18 +153,14 @@ func (s *eventStatements) insertEvent(
 	var eventNID int64
 	var stateNID int64
 	var err error
-	var res sql.Result
 	insertStmt := common.TxStmt(txn, s.insertEventStmt)
 	resultStmt := common.TxStmt(txn, s.insertEventResultStmt)
-	if res, err = insertStmt.ExecContext(
+	if _, err = insertStmt.ExecContext(
 		ctx, int64(roomNID), int64(eventTypeNID), int64(eventStateKeyNID),
 		eventID, referenceSHA256, eventNIDsAsArray(authEventNIDs), depth,
 	); err == nil {
-		a, b := res.LastInsertId()
-		fmt.Println("LastInsertId", a, b)
 		err = resultStmt.QueryRowContext(ctx).Scan(&eventNID, &stateNID)
 	}
-	fmt.Println("INSERT event ID", eventID, "state snapshot NID:", stateNID, "event NID:", eventNID)
 	return types.EventNID(eventNID), types.StateSnapshotNID(stateNID), err
 }
 
@@ -284,14 +280,7 @@ func (s *eventStatements) updateEventState(
 	ctx context.Context, txn *sql.Tx, eventNID types.EventNID, stateNID types.StateSnapshotNID,
 ) error {
 	updateStmt := common.TxStmt(txn, s.updateEventStateStmt)
-	fmt.Println("=====================================")
+	_, err := updateStmt.ExecContext(ctx, int64(stateNID), int64(eventNID))
-	fmt.Println(updateEventStateSQL, stateNID, eventNID)
-	res, err := updateStmt.ExecContext(ctx, int64(stateNID), int64(eventNID))
-	if err != nil {
-		fmt.Println("updateEventState s.updateEventStateStmt.ExecContext:", err)
-	}
-	a, b := res.RowsAffected()
-	fmt.Println("Rows affected:", a, b)
 	return err
 }
 
@@ -302,7 +291,6 @@ func (s *eventStatements) selectEventSentToOutput(
 	err = selectStmt.QueryRowContext(ctx, int64(eventNID)).Scan(&sentToOutput)
 	//err = s.selectEventSentToOutputStmt.QueryRowContext(ctx, int64(eventNID)).Scan(&sentToOutput)
 	if err != nil {
-		fmt.Println("selectEventSentToOutput stmt.QueryRowContext:", err)
 	}
 	return
 }
@@ -311,9 +299,6 @@ func (s *eventStatements) updateEventSentToOutput(ctx context.Context, txn *sql.
 	updateStmt := common.TxStmt(txn, s.updateEventSentToOutputStmt)
 	_, err := updateStmt.ExecContext(ctx, int64(eventNID))
 	//_, err := s.updateEventSentToOutputStmt.ExecContext(ctx, int64(eventNID))
-	if err != nil {
-		fmt.Println("updateEventSentToOutput stmt.QueryRowContext:", err)
-	}
 	return err
 }
 
@@ -322,9 +307,6 @@ func (s *eventStatements) selectEventID(
 ) (eventID string, err error) {
 	selectStmt := common.TxStmt(txn, s.selectEventIDStmt)
 	err = selectStmt.QueryRowContext(ctx, int64(eventNID)).Scan(&eventID)
-	if err != nil {
-		fmt.Println("selectEventID stmt.QueryRowContext:", err)
-	}
 	return
 }
 
@@ -341,7 +323,6 @@ func (s *eventStatements) bulkSelectStateAtEventAndReference(
 
 	rows, err := txn.QueryContext(ctx, selectOrig, iEventNIDs...)
 	if err != nil {
-		fmt.Println("bulkSelectStateAtEventAndREference stmt.QueryContext:", err)
 		return nil, err
 	}
 	defer rows.Close() // nolint: errcheck
@@ -359,7 +340,6 @@ func (s *eventStatements) bulkSelectStateAtEventAndReference(
 		if err = rows.Scan(
 			&eventTypeNID, &eventStateKeyNID, &eventNID, &stateSnapshotNID, &eventID, &eventSHA256,
 		); err != nil {
-			fmt.Println("bulkSelectStateAtEventAndReference rows.Scan:", err)
 			return nil, err
 		}
 		result := &results[i]
@@ -394,7 +374,6 @@ func (s *eventStatements) bulkSelectEventReference(
 	selectStmt := common.TxStmt(txn, selectPrep)
 	rows, err := selectStmt.QueryContext(ctx, iEventNIDs...)
 	if err != nil {
-		fmt.Println("bulkSelectEventReference s.bulkSelectEventReferenceStmt.QueryContext:", err)
 		return nil, err
 	}
 	defer rows.Close() // nolint: errcheck
@@ -403,7 +382,6 @@ func (s *eventStatements) bulkSelectEventReference(
 	for ; rows.Next(); i++ {
 		result := &results[i]
 		if err = rows.Scan(&result.EventID, &result.EventSHA256); err != nil {
-			fmt.Println("bulkSelectEventReference rows.Scan:", err)
 			return nil, err
 		}
 	}
@@ -430,7 +408,6 @@ func (s *eventStatements) bulkSelectEventID(ctx context.Context, txn *sql.Tx, ev
 	selectStmt := common.TxStmt(txn, selectPrep)
 	rows, err := selectStmt.QueryContext(ctx, iEventNIDs...)
 	if err != nil {
-		fmt.Println("bulkSelectEventID s.bulkSelectEventIDStmt.QueryContext:", err)
 		return nil, err
 	}
 	defer rows.Close() // nolint: errcheck
@@ -440,7 +417,6 @@ func (s *eventStatements) bulkSelectEventID(ctx context.Context, txn *sql.Tx, ev
 		var eventNID int64
 		var eventID string
 		if err = rows.Scan(&eventNID, &eventID); err != nil {
-			fmt.Println("bulkSelectEventID rows.Scan:", err)
 			return nil, err
 		}
 		results[types.EventNID(eventNID)] = eventID
@@ -469,7 +445,6 @@ func (s *eventStatements) bulkSelectEventNID(ctx context.Context, txn *sql.Tx, e
 	selectStmt := common.TxStmt(txn, selectPrep)
 	rows, err := selectStmt.QueryContext(ctx, iEventIDs...)
 	if err != nil {
-		fmt.Println("bulkSelectEventNID s.bulkSelectEventNIDStmt.QueryContext:", err)
 		return nil, err
 	}
 	defer rows.Close() // nolint: errcheck
@@ -478,7 +453,6 @@ func (s *eventStatements) bulkSelectEventNID(ctx context.Context, txn *sql.Tx, e
 		var eventID string
 		var eventNID int64
 		if err = rows.Scan(&eventID, &eventNID); err != nil {
-			fmt.Println("bulkSelectEventNID rows.Scan:", err)
 			return nil, err
 		}
 		results[eventID] = types.EventNID(eventNID)
@@ -491,7 +465,6 @@ func (s *eventStatements) selectMaxEventDepth(ctx context.Context, txn *sql.Tx,
 	selectStmt := common.TxStmt(txn, s.selectMaxEventDepthStmt)
 	err := selectStmt.QueryRowContext(ctx, sqliteIn(eventNIDsAsArray(eventNIDs))).Scan(&result)
 	if err != nil {
-		fmt.Println("selectMaxEventDepth stmt.QueryRowContext:", err)
 		return 0, err
 	}
 	return result, nil

roomserver/storage/sqlite3/invite_table.go

@@ -18,7 +18,6 @@ package sqlite3
 import (
 	"context"
 	"database/sql"
-	"fmt"
 
 	"github.com/matrix-org/dendrite/common"
 	"github.com/matrix-org/dendrite/roomserver/types"
@@ -90,12 +89,10 @@ func (s *inviteStatements) insertInviteEvent(
 		ctx, inviteEventID, roomNID, targetUserNID, senderUserNID, inviteEventJSON,
 	)
 	if err != nil {
-		fmt.Println("insertInviteEvent common.TxStmt.ExecContext:", err)
 		return false, err
 	}
 	count, err := result.RowsAffected()
 	if err != nil {
-		fmt.Println("insertInviteEvent result.RowsAffected:", err)
 		return false, err
 	}
 	return count != 0, nil
@@ -108,14 +105,12 @@ func (s *inviteStatements) updateInviteRetired(
 	stmt := common.TxStmt(txn, s.updateInviteRetiredStmt)
 	rows, err := stmt.QueryContext(ctx, roomNID, targetUserNID)
 	if err != nil {
-		fmt.Println("updateInviteRetired stmt.QueryContext:", err)
 		return nil, err
 	}
 	defer (func() { err = rows.Close() })()
 	for rows.Next() {
 		var inviteEventID string
 		if err := rows.Scan(&inviteEventID); err != nil {
-			fmt.Println("updateInviteRetired rows.Scan:", err)
 			return nil, err
 		}
 		eventIDs = append(eventIDs, inviteEventID)
@@ -132,7 +127,6 @@ func (s *inviteStatements) selectInviteActiveForUserInRoom(
 		ctx, targetUserNID, roomNID,
 	)
 	if err != nil {
-		fmt.Println("selectInviteActiveForUserInRoom s.selectInviteActiveForUserInRoomStmt.QueryContext:", err)
 		return nil, err
 	}
 	defer rows.Close() // nolint: errcheck
@@ -140,7 +134,6 @@ func (s *inviteStatements) selectInviteActiveForUserInRoom(
 	for rows.Next() {
 		var senderUserNID int64
 		if err := rows.Scan(&senderUserNID); err != nil {
-			fmt.Println("selectInviteActiveForUserInRoom rows.Scan:", err)
 			return nil, err
 		}
 		result = append(result, types.EventStateKeyNID(senderUserNID))

roomserver/storage/sqlite3/membership_table.go

@@ -18,7 +18,6 @@ package sqlite3
 import (
 	"context"
 	"database/sql"
-	"fmt"
 
 	"github.com/matrix-org/dendrite/common"
 	"github.com/matrix-org/dendrite/roomserver/types"
@@ -101,9 +100,6 @@ func (s *membershipStatements) insertMembership(
 ) error {
 	stmt := common.TxStmt(txn, s.insertMembershipStmt)
 	_, err := stmt.ExecContext(ctx, roomNID, targetUserNID)
-	if err != nil {
-		fmt.Println("insertMembership stmt.ExecContent:", err)
-	}
 	return err
 }
 
@@ -115,9 +111,6 @@ func (s *membershipStatements) selectMembershipForUpdate(
 	err = stmt.QueryRowContext(
 		ctx, roomNID, targetUserNID,
 	).Scan(&membership)
-	if err != nil {
-		fmt.Println("selectMembershipForUpdate common.TxStmt.Scan:", err)
-	}
 	return
 }
 
@@ -129,9 +122,6 @@ func (s *membershipStatements) selectMembershipFromRoomAndTarget(
 	err = selectStmt.QueryRowContext(
 		ctx, roomNID, targetUserNID,
 	).Scan(&membership, &eventNID)
-	if err != nil {
-		fmt.Println("selectMembershipForUpdate s.selectMembershipFromRoomAndTargetStmt.QueryRowContext:", err)
-	}
 	return
 }
 
@@ -142,14 +132,13 @@ func (s *membershipStatements) selectMembershipsFromRoom(
 	selectStmt := common.TxStmt(txn, s.selectMembershipsFromRoomStmt)
 	rows, err := selectStmt.QueryContext(ctx, roomNID)
 	if err != nil {
-		fmt.Println("selectMembershipsFromRoom s.selectMembershipsFromRoomStmt.QueryContext:", err)
+		return nil, err
-		return
 	}
+	defer rows.Close() // nolint: errcheck
 
 	for rows.Next() {
 		var eNID types.EventNID
 		if err = rows.Scan(&eNID); err != nil {
-			fmt.Println("selectMembershipsFromRoom rows.Scan:", err)
 			return
 		}
 		eventNIDs = append(eventNIDs, eNID)
@@ -163,14 +152,13 @@ func (s *membershipStatements) selectMembershipsFromRoomAndMembership(
 	stmt := common.TxStmt(txn, s.selectMembershipsFromRoomAndMembershipStmt)
 	rows, err := stmt.QueryContext(ctx, roomNID, membership)
 	if err != nil {
-		fmt.Println("selectMembershipsFromRoomAndMembership stmt.QueryContext:", err)
 		return
 	}
+	defer rows.Close() // nolint: errcheck
 
 	for rows.Next() {
 		var eNID types.EventNID
 		if err = rows.Scan(&eNID); err != nil {
-			fmt.Println("selectMembershipsFromRoomAndMembership rows.Scan:", err)
 			return
 		}
 		eventNIDs = append(eventNIDs, eNID)
@@ -188,8 +176,5 @@ func (s *membershipStatements) updateMembership(
 	_, err := stmt.ExecContext(
 		ctx, senderUserNID, membership, eventNID, roomNID, targetUserNID,
 	)
-	if err != nil {
-		fmt.Println("updateMembership common.TxStmt.ExecContent:", err)
-	}
 	return err
 }

roomserver/storage/sqlite3/previous_events_table.go

@@ -18,7 +18,6 @@ package sqlite3
 import (
 	"context"
 	"database/sql"
-	"fmt"
 
 	"github.com/matrix-org/dendrite/common"
 	"github.com/matrix-org/dendrite/roomserver/types"
@@ -79,9 +78,6 @@ func (s *previousEventStatements) insertPreviousEvent(
 	_, err := stmt.ExecContext(
 		ctx, previousEventID, previousEventReferenceSHA256, int64(eventNID),
 	)
-	if err != nil {
-		fmt.Println("insertPreviousEvent stmt.ExecContext:", err)
-	}
 	return err
 }
 
@@ -92,8 +88,5 @@ func (s *previousEventStatements) selectPreviousEventExists(
 ) error {
 	var ok int64
 	stmt := common.TxStmt(txn, s.selectPreviousEventExistsStmt)
-	defer func() {
-		fmt.Println("SELECTED PREVIOUS EVENT EXISTS", ok)
-	}()
 	return stmt.QueryRowContext(ctx, eventID, eventReferenceSHA256).Scan(&ok)
 }

roomserver/storage/sqlite3/room_aliases_table.go

@@ -18,7 +18,6 @@ package sqlite3
 import (
 	"context"
 	"database/sql"
-	"fmt"
 
 	"github.com/matrix-org/dendrite/common"
 )
@@ -80,9 +79,6 @@ func (s *roomAliasesStatements) insertRoomAlias(
 ) (err error) {
 	insertStmt := common.TxStmt(txn, s.insertRoomAliasStmt)
 	_, err = insertStmt.ExecContext(ctx, alias, roomID, creatorUserID)
-	if err != nil {
-		fmt.Println("insertRoomAlias s.insertRoomAliasStmt.ExecContent:", err)
-	}
 	return
 }
 
@@ -104,14 +100,12 @@ func (s *roomAliasesStatements) selectAliasesFromRoomID(
 	selectStmt := common.TxStmt(txn, s.selectAliasesFromRoomIDStmt)
 	rows, err := selectStmt.QueryContext(ctx, roomID)
 	if err != nil {
-		fmt.Println("selectAliasesFromRoomID s.selectAliasesFromRoomIDStmt.QueryContext:", err)
 		return
 	}
 
 	for rows.Next() {
 		var alias string
 		if err = rows.Scan(&alias); err != nil {
-			fmt.Println("selectAliasesFromRoomID rows.Scan:", err)
 			return
 		}
 

roomserver/storage/sqlite3/rooms_table.go

@@ -18,7 +18,6 @@ package sqlite3
 import (
 	"context"
 	"database/sql"
-	"fmt"
 
 	"github.com/lib/pq"
 	"github.com/matrix-org/dendrite/common"
@@ -83,7 +82,6 @@ func (s *roomStatements) insertRoomNID(
 	if _, err = insertStmt.ExecContext(ctx, roomID); err == nil {
 		return s.selectRoomNID(ctx, txn, roomID)
 	} else {
-		fmt.Println("insertRoomNID insertStmt.ExecContext:", err)
 		return types.RoomNID(0), err
 	}
 }
@@ -105,7 +103,6 @@ func (s *roomStatements) selectLatestEventNIDs(
 	stmt := common.TxStmt(txn, s.selectLatestEventNIDsStmt)
 	err := stmt.QueryRowContext(ctx, int64(roomNID)).Scan(&nids, &stateSnapshotNID)
 	if err != nil {
-		fmt.Println("selectLatestEventNIDs stmt.QueryRowContext:", err)
 		return nil, 0, err
 	}
 	eventNIDs := make([]types.EventNID, len(nids))
@@ -124,7 +121,6 @@ func (s *roomStatements) selectLatestEventsNIDsForUpdate(
 	stmt := common.TxStmt(txn, s.selectLatestEventNIDsForUpdateStmt)
 	err := stmt.QueryRowContext(ctx, int64(roomNID)).Scan(&nids, &lastEventSentNID, &stateSnapshotNID)
 	if err != nil {
-		fmt.Println("selectLatestEventsNIDsForUpdate stmt.QueryRowContext:", err)
 		return nil, 0, 0, err
 	}
 	eventNIDs := make([]types.EventNID, len(nids))
@@ -150,8 +146,5 @@ func (s *roomStatements) updateLatestEventNIDs(
 		int64(stateSnapshotNID),
 		roomNID,
 	)
-	if err != nil {
-		fmt.Println("updateLatestEventNIDs stmt.ExecContext:", err)
-	}
 	return err
 }

roomserver/storage/sqlite3/state_block_table.go

@@ -19,7 +19,6 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
-	"runtime/debug"
 	"sort"
 	"strings"
 
@@ -111,8 +110,6 @@ func (s *stateBlockStatements) bulkInsertStateData(
 			int64(entry.EventNID),
 		)
 		if err != nil {
-			fmt.Println("bulkInsertStateData s.insertStateDataStmt.ExecContext:", err)
-			debug.PrintStack()
 			return err
 		}
 	}
@@ -132,7 +129,6 @@ func (s *stateBlockStatements) selectNextStateBlockNID(
 func (s *stateBlockStatements) bulkSelectStateBlockEntries(
 	ctx context.Context, txn *sql.Tx, stateBlockNIDs []types.StateBlockNID,
 ) ([]types.StateEntryList, error) {
-	///////////////
 	nids := make([]interface{}, len(stateBlockNIDs))
 	for k, v := range stateBlockNIDs {
 		nids[k] = v
@@ -142,17 +138,9 @@ func (s *stateBlockStatements) bulkSelectStateBlockEntries(
 	if err != nil {
 		return nil, err
 	}
-	///////////////
-	/*
-		nids := make([]int64, len(stateBlockNIDs))
-		for i := range stateBlockNIDs {
-			nids[i] = int64(stateBlockNIDs[i])
-		}
-	*/
 	selectStmt := common.TxStmt(txn, selectPrep)
 	rows, err := selectStmt.QueryContext(ctx, nids...)
 	if err != nil {
-		fmt.Println("bulkSelectStateBlockEntries s.bulkSelectStateBlockEntriesStmt.QueryContext:", err)
 		return nil, err
 	}
 	defer rows.Close() // nolint: errcheck
@@ -172,10 +160,8 @@ func (s *stateBlockStatements) bulkSelectStateBlockEntries(
 		if err := rows.Scan(
 			&stateBlockNID, &eventTypeNID, &eventStateKeyNID, &eventNID,
 		); err != nil {
-			fmt.Println("bulkSelectStateBlockEntries rows.Scan:", err)
 			return nil, err
 		}
-		fmt.Println("state block NID", stateBlockNID, "event type NID", eventTypeNID, "event state key NID", eventStateKeyNID, "event NID", eventNID)
 		entry.EventTypeNID = types.EventTypeNID(eventTypeNID)
 		entry.EventStateKeyNID = types.EventStateKeyNID(eventStateKeyNID)
 		entry.EventNID = types.EventNID(eventNID)
@@ -225,7 +211,6 @@ func (s *stateBlockStatements) bulkSelectFilteredStateBlockEntries(
 		params...,
 	)
 	if err != nil {
-		fmt.Println("bulkSelectFilteredStateBlockEntries s.bulkSelectFilteredStateBlockEntriesStmt.QueryContext:", err)
 		return nil, err
 	}
 	defer rows.Close() // nolint: errcheck
@@ -243,7 +228,6 @@ func (s *stateBlockStatements) bulkSelectFilteredStateBlockEntries(
 		if err := rows.Scan(
 			&stateBlockNID, &eventTypeNID, &eventStateKeyNID, &eventNID,
 		); err != nil {
-			fmt.Println("bulkSelectFilteredStateBlockEntries rows.Scan:", err)
 			return nil, err
 		}
 		entry.EventTypeNID = types.EventTypeNID(eventTypeNID)

roomserver/storage/sqlite3/state_snapshot_table.go

@@ -72,16 +72,12 @@ func (s *stateSnapshotStatements) insertState(
 		nids[i] = int64(stateBlockNIDs[i])
 	}
 	insertStmt := txn.Stmt(s.insertStateStmt)
-	//resultStmt := txn.Stmt(s.insertStateResultStmt)
-	fmt.Println(insertStateSQL, roomNID, nids)
 	if res, err2 := insertStmt.ExecContext(ctx, int64(roomNID), pq.Int64Array(nids)); err2 == nil {
 		lastRowID, err3 := res.LastInsertId()
 		if err3 != nil {
 			err = err3
 		}
 		stateNID = types.StateSnapshotNID(lastRowID)
-	} else {
-		fmt.Println("insertState s.insertStateStmt.ExecContext:", err2)
 	}
 	return
 }
@@ -89,7 +85,6 @@ func (s *stateSnapshotStatements) insertState(
 func (s *stateSnapshotStatements) bulkSelectStateBlockNIDs(
 	ctx context.Context, txn *sql.Tx, stateNIDs []types.StateSnapshotNID,
 ) ([]types.StateBlockNIDList, error) {
-	///////////////
 	nids := make([]interface{}, len(stateNIDs))
 	for k, v := range stateNIDs {
 		nids[k] = v
@@ -99,16 +94,9 @@ func (s *stateSnapshotStatements) bulkSelectStateBlockNIDs(
 	if err != nil {
 		return nil, err
 	}
-	///////////////
+
-	/*
-		nids := make([]int64, len(stateNIDs))
-		for i := range stateNIDs {
-			nids[i] = int64(stateNIDs[i])
-		}
-	*/
 	rows, err := selectStmt.QueryContext(ctx, nids...)
 	if err != nil {
-		fmt.Println("bulkSelectStateBlockNIDs s.bulkSelectStateBlockNIDsStmt.QueryContext:", err)
 		return nil, err
 	}
 	defer rows.Close() // nolint: errcheck
@@ -118,7 +106,6 @@ func (s *stateSnapshotStatements) bulkSelectStateBlockNIDs(
 		result := &results[i]
 		var stateBlockNIDs pq.Int64Array
 		if err := rows.Scan(&result.StateSnapshotNID, &stateBlockNIDs); err != nil {
-			fmt.Println("bulkSelectStateBlockNIDs rows.Scan:", err)
 			return nil, err
 		}
 		result.StateBlockNIDs = make([]types.StateBlockNID, len(stateBlockNIDs))

roomserver/storage/sqlite3/transactions_table.go

@@ -18,7 +18,6 @@ package sqlite3
 import (
 	"context"
 	"database/sql"
-	"fmt"
 
 	"github.com/matrix-org/dendrite/common"
 )
@@ -70,9 +69,6 @@ func (s *transactionStatements) insertTransaction(
 	_, err = stmt.ExecContext(
 		ctx, transactionID, sessionID, userID, eventID,
 	)
-	if err != nil {
-		fmt.Println("insertTransaction s.insertTransactionStmt.ExecContent:", err)
-	}
 	return
 }
 
@@ -86,8 +82,5 @@ func (s *transactionStatements) selectTransactionEventID(
 	err = stmt.QueryRowContext(
 		ctx, transactionID, sessionID, userID,
 	).Scan(&eventID)
-	if err != nil {
-		fmt.Println("selectTransactionEventID s.selectTransactionEventIDStmt.QueryRowContext:", err)
-	}
 	return
 }