From 57d05d4c7973a520560ead559d32af05025514d8 Mon Sep 17 00:00:00 2001 From: Kegan Dougal Date: Wed, 12 Feb 2020 16:48:31 +0000 Subject: [PATCH] Nuke fmt.println --- roomserver/input/events.go | 5 --- roomserver/state/state.go | 5 --- roomserver/storage/postgres/events_table.go | 2 -- .../storage/sqlite3/event_state_keys_table.go | 3 -- roomserver/storage/sqlite3/events_table.go | 31 ++----------------- roomserver/storage/sqlite3/invite_table.go | 7 ----- .../storage/sqlite3/membership_table.go | 21 ++----------- .../storage/sqlite3/previous_events_table.go | 7 ----- .../storage/sqlite3/room_aliases_table.go | 6 ---- roomserver/storage/sqlite3/rooms_table.go | 7 ----- .../storage/sqlite3/state_block_table.go | 16 ---------- .../storage/sqlite3/state_snapshot_table.go | 15 +-------- .../storage/sqlite3/transactions_table.go | 7 ----- 13 files changed, 6 insertions(+), 126 deletions(-) diff --git a/roomserver/input/events.go b/roomserver/input/events.go index 11bd51749..b30c39928 100644 --- a/roomserver/input/events.go +++ b/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) } diff --git a/roomserver/state/state.go b/roomserver/state/state.go index dbb04eb01..1cbb4d12b 100644 --- a/roomserver/state/state.go +++ b/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) } diff --git a/roomserver/storage/postgres/events_table.go b/roomserver/storage/postgres/events_table.go index 8c381396c..1e8a5665b 100644 --- a/roomserver/storage/postgres/events_table.go +++ b/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 } diff --git a/roomserver/storage/sqlite3/event_state_keys_table.go b/roomserver/storage/sqlite3/event_state_keys_table.go index 899845baf..26771de33 100644 --- a/roomserver/storage/sqlite3/event_state_keys_table.go +++ b/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 } diff --git a/roomserver/storage/sqlite3/events_table.go b/roomserver/storage/sqlite3/events_table.go index 2d0fe2073..15ec7b7f2 100644 --- a/roomserver/storage/sqlite3/events_table.go +++ b/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("=====================================") - 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) + _, err := updateStmt.ExecContext(ctx, int64(stateNID), int64(eventNID)) 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 diff --git a/roomserver/storage/sqlite3/invite_table.go b/roomserver/storage/sqlite3/invite_table.go index 413736e82..4ca8cb2b1 100644 --- a/roomserver/storage/sqlite3/invite_table.go +++ b/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)) diff --git a/roomserver/storage/sqlite3/membership_table.go b/roomserver/storage/sqlite3/membership_table.go index 525364213..978776738 100644 --- a/roomserver/storage/sqlite3/membership_table.go +++ b/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 + return nil, err } + 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 } diff --git a/roomserver/storage/sqlite3/previous_events_table.go b/roomserver/storage/sqlite3/previous_events_table.go index ebac96114..9ed64a38e 100644 --- a/roomserver/storage/sqlite3/previous_events_table.go +++ b/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) } diff --git a/roomserver/storage/sqlite3/room_aliases_table.go b/roomserver/storage/sqlite3/room_aliases_table.go index b4a5735f3..a5fd5449a 100644 --- a/roomserver/storage/sqlite3/room_aliases_table.go +++ b/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 } diff --git a/roomserver/storage/sqlite3/rooms_table.go b/roomserver/storage/sqlite3/rooms_table.go index a8d299f06..fb5ff219c 100644 --- a/roomserver/storage/sqlite3/rooms_table.go +++ b/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 } diff --git a/roomserver/storage/sqlite3/state_block_table.go b/roomserver/storage/sqlite3/state_block_table.go index 44d9fc4db..5c1829833 100644 --- a/roomserver/storage/sqlite3/state_block_table.go +++ b/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) diff --git a/roomserver/storage/sqlite3/state_snapshot_table.go b/roomserver/storage/sqlite3/state_snapshot_table.go index 6d9727d5c..1cecb3778 100644 --- a/roomserver/storage/sqlite3/state_snapshot_table.go +++ b/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)) diff --git a/roomserver/storage/sqlite3/transactions_table.go b/roomserver/storage/sqlite3/transactions_table.go index 5ff6d215e..7740e5f07 100644 --- a/roomserver/storage/sqlite3/transactions_table.go +++ b/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 }