mirrors/dendrite
1
0
Fork 0
mirror of https://github.com/matrix-org/dendrite.git synced 2026-01-16 18:43:10 -06:00
Code Issues Packages Projects Releases Wiki Activity

Move everything to sqlutil.Statementlist

Browse source
This commit is contained in:
Till Faelligen 2023-03-23 12:18:15 +01:00
parent cb18ba0230
commit a182dfec90
No known key found for this signature in database
GPG key ID: ACCDC9606D472758
23 changed files with 126 additions and 245 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
federationapi/storage/postgres/blacklist_table.go
View file

@ -60,19 +60,12 @@ func NewPostgresBlacklistTable(db *sql.DB) (s *blacklistStatements, err error) {
return
}
if s.insertBlacklistStmt, err = db.Prepare(insertBlacklistSQL); err != nil {
return
}
if s.selectBlacklistStmt, err = db.Prepare(selectBlacklistSQL); err != nil {
return
}
if s.deleteBlacklistStmt, err = db.Prepare(deleteBlacklistSQL); err != nil {
return
}
if s.deleteAllBlacklistStmt, err = db.Prepare(deleteAllBlacklistSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.insertBlacklistStmt, insertBlacklistSQL},
{&s.selectBlacklistStmt, selectBlacklistSQL},
{&s.deleteBlacklistStmt, deleteBlacklistSQL},
{&s.deleteAllBlacklistStmt, deleteAllBlacklistSQL},
}.Prepare(db)
}
func (s *blacklistStatements) InsertBlacklist(

28
federationapi/storage/postgres/joined_hosts_table.go
View file

@ -93,25 +93,15 @@ func NewPostgresJoinedHostsTable(db *sql.DB) (s *joinedHostsStatements, err erro
if s.insertJoinedHostsStmt, err = s.db.Prepare(insertJoinedHostsSQL); err != nil {
return
}
if s.deleteJoinedHostsStmt, err = s.db.Prepare(deleteJoinedHostsSQL); err != nil {
return
}
if s.deleteJoinedHostsForRoomStmt, err = s.db.Prepare(deleteJoinedHostsForRoomSQL); err != nil {
return
}
if s.selectJoinedHostsStmt, err = s.db.Prepare(selectJoinedHostsSQL); err != nil {
return
}
if s.selectAllJoinedHostsStmt, err = s.db.Prepare(selectAllJoinedHostsSQL); err != nil {
return
}
if s.selectJoinedHostsForRoomsStmt, err = s.db.Prepare(selectJoinedHostsForRoomsSQL); err != nil {
return
}
if s.selectJoinedHostsForRoomsExcludingBlacklistedStmt, err = s.db.Prepare(selectJoinedHostsForRoomsExcludingBlacklistedSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.insertJoinedHostsStmt, insertJoinedHostsSQL},
{&s.deleteJoinedHostsStmt, deleteJoinedHostsSQL},
{&s.deleteJoinedHostsForRoomStmt, deleteJoinedHostsForRoomSQL},
{&s.selectJoinedHostsStmt, selectJoinedHostsSQL},
{&s.selectAllJoinedHostsStmt, selectAllJoinedHostsSQL},
{&s.selectJoinedHostsForRoomsStmt, selectJoinedHostsForRoomsSQL},
{&s.selectJoinedHostsForRoomsExcludingBlacklistedStmt, selectJoinedHostsForRoomsExcludingBlacklistedSQL},
}.Prepare(db)
}
func (s *joinedHostsStatements) InsertJoinedHosts(

8
federationapi/storage/postgres/notary_server_keys_json_table.go
View file

@ -19,6 +19,7 @@ import (
"database/sql"
"github.com/matrix-org/dendrite/federationapi/storage/tables"
"github.com/matrix-org/dendrite/internal/sqlutil"
"github.com/matrix-org/gomatrixserverlib"
)
@ -50,10 +51,9 @@ func NewPostgresNotaryServerKeysTable(db *sql.DB) (s *notaryServerKeysStatements
return
}
if s.insertServerKeysJSONStmt, err = db.Prepare(insertServerKeysJSONSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.insertServerKeysJSONStmt, insertServerKeysJSONSQL},
}.Prepare(db)
}
func (s *notaryServerKeysStatements) InsertJSONResponse(

24
federationapi/storage/postgres/notary_server_keys_metadata_table.go
View file

@ -22,6 +22,7 @@ import (
"github.com/lib/pq"
"github.com/matrix-org/dendrite/federationapi/storage/tables"
"github.com/matrix-org/dendrite/internal"
"github.com/matrix-org/dendrite/internal/sqlutil"
"github.com/matrix-org/gomatrixserverlib"
)
@ -91,22 +92,13 @@ func NewPostgresNotaryServerKeysMetadataTable(db *sql.DB) (s *notaryServerKeysMe
return
}
if s.upsertServerKeysStmt, err = db.Prepare(upsertServerKeysSQL); err != nil {
return
}
if s.selectNotaryKeyResponsesStmt, err = db.Prepare(selectNotaryKeyResponsesSQL); err != nil {
return
}
if s.selectNotaryKeyResponsesWithKeyIDsStmt, err = db.Prepare(selectNotaryKeyResponsesWithKeyIDsSQL); err != nil {
return
}
if s.selectNotaryKeyMetadataStmt, err = db.Prepare(selectNotaryKeyMetadataSQL); err != nil {
return
}
if s.deleteUnusedServerKeysJSONStmt, err = db.Prepare(deleteUnusedServerKeysJSONSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.upsertServerKeysStmt, upsertServerKeysSQL},
{&s.selectNotaryKeyResponsesStmt, selectNotaryKeyResponsesSQL},
{&s.selectNotaryKeyResponsesWithKeyIDsStmt, selectNotaryKeyResponsesWithKeyIDsSQL},
{&s.selectNotaryKeyMetadataStmt, selectNotaryKeyMetadataSQL},
{&s.deleteUnusedServerKeysJSONStmt, deleteUnusedServerKeysJSONSQL},
}.Prepare(db)
}
func (s *notaryServerKeysMetadataStatements) UpsertKey(

15
federationapi/storage/postgres/queue_json_table.go
View file

@ -65,16 +65,11 @@ func NewPostgresQueueJSONTable(db *sql.DB) (s *queueJSONStatements, err error) {
if err != nil {
return
}
if s.insertJSONStmt, err = s.db.Prepare(insertJSONSQL); err != nil {
return
}
if s.deleteJSONStmt, err = s.db.Prepare(deleteJSONSQL); err != nil {
return
}
if s.selectJSONStmt, err = s.db.Prepare(selectJSONSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.insertJSONStmt, insertJSONSQL},
{&s.deleteJSONStmt, deleteJSONSQL},
{&s.selectJSONStmt, selectJSONSQL},
}.Prepare(db)
}
func (s *queueJSONStatements) InsertQueueJSON(

23
federationapi/storage/postgres/queue_pdus_table.go
View file

@ -78,22 +78,13 @@ func NewPostgresQueuePDUsTable(db *sql.DB) (s *queuePDUsStatements, err error) {
if err != nil {
return
}
if s.insertQueuePDUStmt, err = s.db.Prepare(insertQueuePDUSQL); err != nil {
return
}
if s.deleteQueuePDUsStmt, err = s.db.Prepare(deleteQueuePDUSQL); err != nil {
return
}
if s.selectQueuePDUsStmt, err = s.db.Prepare(selectQueuePDUsSQL); err != nil {
return
}
if s.selectQueuePDUReferenceJSONCountStmt, err = s.db.Prepare(selectQueuePDUReferenceJSONCountSQL); err != nil {
return
}
if s.selectQueuePDUServerNamesStmt, err = s.db.Prepare(selectQueuePDUServerNamesSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.insertQueuePDUStmt, insertQueuePDUSQL},
{&s.deleteQueuePDUsStmt, deleteQueuePDUSQL},
{&s.selectQueuePDUsStmt, selectQueuePDUsSQL},
{&s.selectQueuePDUReferenceJSONCountStmt, selectQueuePDUReferenceJSONCountSQL},
{&s.selectQueuePDUServerNamesStmt, selectQueuePDUServerNamesSQL},
}.Prepare(db)
}
func (s *queuePDUsStatements) InsertQueuePDU(

11
federationapi/storage/postgres/server_key_table.go
View file

@ -72,13 +72,10 @@ func NewPostgresServerSigningKeysTable(db *sql.DB) (s *serverSigningKeyStatement
if err != nil {
return
}
if s.bulkSelectServerKeysStmt, err = db.Prepare(bulkSelectServerSigningKeysSQL); err != nil {
return
}
if s.upsertServerKeysStmt, err = db.Prepare(upsertServerSigningKeysSQL); err != nil {
return
}
return s, nil
return s, sqlutil.StatementList{
{&s.bulkSelectServerKeysStmt, bulkSelectServerSigningKeysSQL},
{&s.upsertServerKeysStmt, upsertServerSigningKeysSQL},
}.Prepare(db)
}
func (s *serverSigningKeyStatements) BulkSelectServerKeys(

19
federationapi/storage/sqlite3/blacklist_table.go
View file

@ -60,19 +60,12 @@ func NewSQLiteBlacklistTable(db *sql.DB) (s *blacklistStatements, err error) {
return
}
if s.insertBlacklistStmt, err = db.Prepare(insertBlacklistSQL); err != nil {
return
}
if s.selectBlacklistStmt, err = db.Prepare(selectBlacklistSQL); err != nil {
return
}
if s.deleteBlacklistStmt, err = db.Prepare(deleteBlacklistSQL); err != nil {
return
}
if s.deleteAllBlacklistStmt, err = db.Prepare(deleteAllBlacklistSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.insertBlacklistStmt, insertBlacklistSQL},
{&s.selectBlacklistStmt, selectBlacklistSQL},
{&s.deleteBlacklistStmt, deleteBlacklistSQL},
{&s.deleteAllBlacklistStmt, deleteAllBlacklistSQL},
}.Prepare(db)
}
func (s *blacklistStatements) InsertBlacklist(

24
federationapi/storage/sqlite3/joined_hosts_table.go
View file

@ -90,22 +90,14 @@ func NewSQLiteJoinedHostsTable(db *sql.DB) (s *joinedHostsStatements, err error)
if err != nil {
return
}
if s.insertJoinedHostsStmt, err = db.Prepare(insertJoinedHostsSQL); err != nil {
return
}
if s.deleteJoinedHostsStmt, err = db.Prepare(deleteJoinedHostsSQL); err != nil {
return
}
if s.deleteJoinedHostsForRoomStmt, err = s.db.Prepare(deleteJoinedHostsForRoomSQL); err != nil {
return
}
if s.selectJoinedHostsStmt, err = db.Prepare(selectJoinedHostsSQL); err != nil {
return
}
if s.selectAllJoinedHostsStmt, err = db.Prepare(selectAllJoinedHostsSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.insertJoinedHostsStmt, insertJoinedHostsSQL},
{&s.deleteJoinedHostsStmt, deleteJoinedHostsSQL},
{&s.deleteJoinedHostsForRoomStmt, deleteJoinedHostsForRoomSQL},
{&s.selectJoinedHostsStmt, selectJoinedHostsSQL},
{&s.selectAllJoinedHostsStmt, selectAllJoinedHostsSQL},
}.Prepare(db)
}
func (s *joinedHostsStatements) InsertJoinedHosts(

8
federationapi/storage/sqlite3/notary_server_keys_json_table.go
View file

@ -19,6 +19,7 @@ import (
"database/sql"
"github.com/matrix-org/dendrite/federationapi/storage/tables"
"github.com/matrix-org/dendrite/internal/sqlutil"
"github.com/matrix-org/gomatrixserverlib"
)
@ -49,10 +50,9 @@ func NewSQLiteNotaryServerKeysTable(db *sql.DB) (s *notaryServerKeysStatements,
return
}
if s.insertServerKeysJSONStmt, err = db.Prepare(insertServerKeysJSONSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.insertServerKeysJSONStmt, insertServerKeysJSONSQL},
}.Prepare(db)
}
func (s *notaryServerKeysStatements) InsertJSONResponse(

19
federationapi/storage/sqlite3/notary_server_keys_metadata_table.go
View file

@ -92,19 +92,12 @@ func NewSQLiteNotaryServerKeysMetadataTable(db *sql.DB) (s *notaryServerKeysMeta
return
}
if s.upsertServerKeysStmt, err = db.Prepare(upsertServerKeysSQL); err != nil {
return
}
if s.selectNotaryKeyResponsesStmt, err = db.Prepare(selectNotaryKeyResponsesSQL); err != nil {
return
}
if s.selectNotaryKeyMetadataStmt, err = db.Prepare(selectNotaryKeyMetadataSQL); err != nil {
return
}
if s.deleteUnusedServerKeysJSONStmt, err = db.Prepare(deleteUnusedServerKeysJSONSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.upsertServerKeysStmt, upsertServerKeysSQL},
{&s.selectNotaryKeyResponsesStmt, selectNotaryKeyResponsesSQL},
{&s.selectNotaryKeyMetadataStmt, selectNotaryKeyMetadataSQL},
{&s.deleteUnusedServerKeysJSONStmt, deleteUnusedServerKeysJSONSQL},
}.Prepare(db)
}
func (s *notaryServerKeysMetadataStatements) UpsertKey(

8
federationapi/storage/sqlite3/queue_json_table.go
View file

@ -66,10 +66,10 @@ func NewSQLiteQueueJSONTable(db *sql.DB) (s *queueJSONStatements, err error) {
if err != nil {
return
}
if s.insertJSONStmt, err = db.Prepare(insertJSONSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.insertJSONStmt, insertJSONSQL},
}.Prepare(db)
}
func (s *queueJSONStatements) InsertQueueJSON(

26
federationapi/storage/sqlite3/queue_pdus_table.go
View file

@ -87,25 +87,13 @@ func NewSQLiteQueuePDUsTable(db *sql.DB) (s *queuePDUsStatements, err error) {
if err != nil {
return
}
if s.insertQueuePDUStmt, err = db.Prepare(insertQueuePDUSQL); err != nil {
return
}
//if s.deleteQueuePDUsStmt, err = db.Prepare(deleteQueuePDUsSQL); err != nil {
// return
//}
if s.selectQueueNextTransactionIDStmt, err = db.Prepare(selectQueueNextTransactionIDSQL); err != nil {
return
}
if s.selectQueuePDUsStmt, err = db.Prepare(selectQueuePDUsSQL); err != nil {
return
}
if s.selectQueueReferenceJSONCountStmt, err = db.Prepare(selectQueuePDUsReferenceJSONCountSQL); err != nil {
return
}
if s.selectQueueServerNamesStmt, err = db.Prepare(selectQueuePDUsServerNamesSQL); err != nil {
return
}
return
return s, sqlutil.StatementList{
{&s.insertQueuePDUStmt, insertQueuePDUSQL},
{&s.selectQueueNextTransactionIDStmt, selectQueueNextTransactionIDSQL},
{&s.selectQueuePDUsStmt, selectQueuePDUsSQL},
{&s.selectQueueReferenceJSONCountStmt, selectQueuePDUsReferenceJSONCountSQL},
{&s.selectQueueServerNamesStmt, selectQueuePDUsServerNamesSQL},
}.Prepare(db)
}
func (s *queuePDUsStatements) InsertQueuePDU(

11
federationapi/storage/sqlite3/server_key_table.go
View file

@ -74,13 +74,10 @@ func NewSQLiteServerSigningKeysTable(db *sql.DB) (s *serverSigningKeyStatements,
if err != nil {
return
}
if s.bulkSelectServerKeysStmt, err = db.Prepare(bulkSelectServerSigningKeysSQL); err != nil {
return
}
if s.upsertServerKeysStmt, err = db.Prepare(upsertServerSigningKeysSQL); err != nil {
return
}
return s, nil
return s, sqlutil.StatementList{
{&s.bulkSelectServerKeysStmt, bulkSelectServerSigningKeysSQL},
{&s.upsertServerKeysStmt, upsertServerSigningKeysSQL},
}.Prepare(db)
}
func (s *serverSigningKeyStatements) BulkSelectServerKeys(

15
syncapi/storage/postgres/account_data_table.go
View file

@ -78,16 +78,11 @@ func NewPostgresAccountDataTable(db *sql.DB) (tables.AccountData, error) {
if err != nil {
return nil, err
}
if s.insertAccountDataStmt, err = db.Prepare(insertAccountDataSQL); err != nil {
return nil, err
}
if s.selectAccountDataInRangeStmt, err = db.Prepare(selectAccountDataInRangeSQL); err != nil {
return nil, err
}
if s.selectMaxAccountDataIDStmt, err = db.Prepare(selectMaxAccountDataIDSQL); err != nil {
return nil, err
}
return s, nil
return s, sqlutil.StatementList{
{&s.insertAccountDataStmt, insertAccountDataSQL},
{&s.selectAccountDataInRangeStmt, selectAccountDataInRangeSQL},
{&s.selectMaxAccountDataIDStmt, selectMaxAccountDataIDSQL},
}.Prepare(db)
}
func (s *accountDataStatements) InsertAccountData(

15
syncapi/storage/postgres/filter_table.go
View file

@ -61,16 +61,11 @@ func NewPostgresFilterTable(db *sql.DB) (tables.Filter, error) {
return nil, err
}
s := &filterStatements{}
if s.selectFilterStmt, err = db.Prepare(selectFilterSQL); err != nil {
return nil, err
}
if s.selectFilterIDByContentStmt, err = db.Prepare(selectFilterIDByContentSQL); err != nil {
return nil, err
}
if s.insertFilterStmt, err = db.Prepare(insertFilterSQL); err != nil {
return nil, err
}
return s, nil
return s, sqlutil.StatementList{
{&s.selectFilterStmt, selectFilterSQL},
{&s.selectFilterIDByContentStmt, selectFilterIDByContentSQL},
{&s.insertFilterStmt, insertFilterSQL},
}.Prepare(db)
}
func (s *filterStatements) SelectFilter(

12
syncapi/storage/postgres/ignores_table.go
View file

@ -52,13 +52,11 @@ func NewPostgresIgnoresTable(db *sql.DB) (tables.Ignores, error) {
return nil, err
}
s := &ignoresStatements{}
if s.selectIgnoresStmt, err = db.Prepare(selectIgnoresSQL); err != nil {
return nil, err
}
if s.upsertIgnoresStmt, err = db.Prepare(upsertIgnoresSQL); err != nil {
return nil, err
}
return s, nil
return s, sqlutil.StatementList{
{&s.selectIgnoresStmt, selectIgnoresSQL},
{&s.upsertIgnoresStmt, upsertIgnoresSQL},
}.Prepare(db)
}
func (s *ignoresStatements) SelectIgnores(

19
syncapi/storage/postgres/send_to_device_table.go
View file

@ -88,19 +88,12 @@ func NewPostgresSendToDeviceTable(db *sql.DB) (tables.SendToDevice, error) {
if err != nil {
return nil, err
}
if s.insertSendToDeviceMessageStmt, err = db.Prepare(insertSendToDeviceMessageSQL); err != nil {
return nil, err
}
if s.selectSendToDeviceMessagesStmt, err = db.Prepare(selectSendToDeviceMessagesSQL); err != nil {
return nil, err
}
if s.deleteSendToDeviceMessagesStmt, err = db.Prepare(deleteSendToDeviceMessagesSQL); err != nil {
return nil, err
}
if s.selectMaxSendToDeviceIDStmt, err = db.Prepare(selectMaxSendToDeviceIDSQL); err != nil {
return nil, err
}
return s, nil
return s, sqlutil.StatementList{
{&s.insertSendToDeviceMessageStmt, insertSendToDeviceMessageSQL},
{&s.selectSendToDeviceMessagesStmt, selectSendToDeviceMessagesSQL},
{&s.deleteSendToDeviceMessagesStmt, deleteSendToDeviceMessagesSQL},
{&s.selectMaxSendToDeviceIDStmt, selectMaxSendToDeviceIDSQL},
}.Prepare(db)
}
func (s *sendToDeviceStatements) InsertSendToDeviceMessage(

15
syncapi/storage/sqlite3/account_data_table.go
View file

@ -66,16 +66,11 @@ func NewSqliteAccountDataTable(db *sql.DB, streamID *StreamIDStatements) (tables
if err != nil {
return nil, err
}
if s.insertAccountDataStmt, err = db.Prepare(insertAccountDataSQL); err != nil {
return nil, err
}
if s.selectMaxAccountDataIDStmt, err = db.Prepare(selectMaxAccountDataIDSQL); err != nil {
return nil, err
}
if s.selectAccountDataInRangeStmt, err = db.Prepare(selectAccountDataInRangeSQL); err != nil {
return nil, err
}
return s, nil
return s, sqlutil.StatementList{
{&s.insertAccountDataStmt, insertAccountDataSQL},
{&s.selectMaxAccountDataIDStmt, selectMaxAccountDataIDSQL},
{&s.selectAccountDataInRangeStmt, selectAccountDataInRangeSQL},
}.Prepare(db)
}
func (s *accountDataStatements) InsertAccountData(

15
syncapi/storage/sqlite3/filter_table.go
View file

@ -65,16 +65,11 @@ func NewSqliteFilterTable(db *sql.DB) (tables.Filter, error) {
s := &filterStatements{
db: db,
}
if s.selectFilterStmt, err = db.Prepare(selectFilterSQL); err != nil {
return nil, err
}
if s.selectFilterIDByContentStmt, err = db.Prepare(selectFilterIDByContentSQL); err != nil {
return nil, err
}
if s.insertFilterStmt, err = db.Prepare(insertFilterSQL); err != nil {
return nil, err
}
return s, nil
return s, sqlutil.StatementList{
{&s.selectFilterStmt, selectFilterSQL},
{&s.selectFilterIDByContentStmt, selectFilterIDByContentSQL},
{&s.insertFilterStmt, insertFilterSQL},
}.Prepare(db)
}
func (s *filterStatements) SelectFilter(

11
syncapi/storage/sqlite3/ignores_table.go
View file

@ -52,13 +52,10 @@ func NewSqliteIgnoresTable(db *sql.DB) (tables.Ignores, error) {
return nil, err
}
s := &ignoresStatements{}
if s.selectIgnoresStmt, err = db.Prepare(selectIgnoresSQL); err != nil {
return nil, err
}
if s.upsertIgnoresStmt, err = db.Prepare(upsertIgnoresSQL); err != nil {
return nil, err
}
return s, nil
return s, sqlutil.StatementList{
{&s.selectIgnoresStmt, selectIgnoresSQL},
{&s.upsertIgnoresStmt, upsertIgnoresSQL},
}.Prepare(db)
}
func (s *ignoresStatements) SelectIgnores(

19
syncapi/storage/sqlite3/send_to_device_table.go
View file

@ -88,19 +88,12 @@ func NewSqliteSendToDeviceTable(db *sql.DB) (tables.SendToDevice, error) {
if err != nil {
return nil, err
}
if s.insertSendToDeviceMessageStmt, err = db.Prepare(insertSendToDeviceMessageSQL); err != nil {
return nil, err
}
if s.selectSendToDeviceMessagesStmt, err = db.Prepare(selectSendToDeviceMessagesSQL); err != nil {
return nil, err
}
if s.deleteSendToDeviceMessagesStmt, err = db.Prepare(deleteSendToDeviceMessagesSQL); err != nil {
return nil, err
}
if s.selectMaxSendToDeviceIDStmt, err = db.Prepare(selectMaxSendToDeviceIDSQL); err != nil {
return nil, err
}
return s, nil
return s, sqlutil.StatementList{
{&s.insertSendToDeviceMessageStmt, insertSendToDeviceMessageSQL},
{&s.selectSendToDeviceMessagesStmt, selectSendToDeviceMessagesSQL},
{&s.deleteSendToDeviceMessagesStmt, deleteSendToDeviceMessagesSQL},
{&s.selectMaxSendToDeviceIDStmt, selectMaxSendToDeviceIDSQL},
}.Prepare(db)
}
func (s *sendToDeviceStatements) InsertSendToDeviceMessage(

7
syncapi/storage/sqlite3/stream_id_table.go
View file

@ -47,10 +47,9 @@ func (s *StreamIDStatements) Prepare(db *sql.DB) (err error) {
if err != nil {
return
}
if s.increaseStreamIDStmt, err = db.Prepare(increaseStreamIDStmt); err != nil {
return
}
return
return sqlutil.StatementList{
{&s.increaseStreamIDStmt, increaseStreamIDStmt},
}.Prepare(db)
}
func (s *StreamIDStatements) nextPDUID(ctx context.Context, txn *sql.Tx) (pos types.StreamPosition, err error) {