mirrors/dendrite
1
0
Fork 0
mirror of https://github.com/matrix-org/dendrite.git synced 2025-12-16 11:23:11 -06:00
Code Issues Packages Projects Releases Wiki Activity

Nuke fmt.println

Browse source
This commit is contained in:
Kegan Dougal 2020-02-12 16:48:31 +00:00
parent 648f05c204
commit 57d05d4c79
13 changed files with 6 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
roomserver/input/events.go
View file

@ -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)
}

5
roomserver/state/state.go
View file

@ -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)
}

2
roomserver/storage/postgres/events_table.go
View file

@ -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
}

3
roomserver/storage/sqlite3/event_state_keys_table.go
View file

@ -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
}

31
roomserver/storage/sqlite3/events_table.go
View file

@ -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

7
roomserver/storage/sqlite3/invite_table.go
View file

@ -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))

21
roomserver/storage/sqlite3/membership_table.go
View file

@ -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
}

7
roomserver/storage/sqlite3/previous_events_table.go
View file

@ -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)
}

6
roomserver/storage/sqlite3/room_aliases_table.go
View file

@ -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
}

7
roomserver/storage/sqlite3/rooms_table.go
View file

@ -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
}

16
roomserver/storage/sqlite3/state_block_table.go
View file

@ -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)

15
roomserver/storage/sqlite3/state_snapshot_table.go
View file

@ -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))

7
roomserver/storage/sqlite3/transactions_table.go
View file

@ -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
}