state

May 23, 2024

Changes in this version

+ const BucketNew

+ const BucketSent

type DeviceDataRow

+ KeyData []byte

+ type DeviceListChunker []DeviceListRow

+ func (c DeviceListChunker) Len() int

+ func (c DeviceListChunker) Subslice(i, j int) sqlutil.Chunker

+ type DeviceListRow struct

+ Bucket int

+ DeviceID string

+ TargetState int

+ TargetUserID string

+ UserID string

+ type DeviceListTable struct

+ func NewDeviceListTable(db *sqlx.DB) *DeviceListTable

+ func (t *DeviceListTable) Select(userID, deviceID string, swap bool) (result internal.MapStringInt, err error)

+ func (t *DeviceListTable) SelectTx(txn *sqlx.Tx, userID, deviceID string, swap bool) (result internal.MapStringInt, err error)

+ func (t *DeviceListTable) Upsert(userID, deviceID string, deviceListChanges map[string]int) (err error)

+ func (t *DeviceListTable) UpsertTx(txn *sqlx.Tx, userID, deviceID string, deviceListChanges map[string]int) (err error)

Apr 26, 2024

Changes in this version

type Storage

+ MaxTimelineLimit int

+ func (s *Storage) Cleaner(n time.Duration)

+ func (s *Storage) RemoveInaccessibleStateSnapshots() error

Nov 24, 2023

Changes in this version

type InitialiseResult

+ ReplacedExistingSnapshot bool

type Storage

+ func (s *Storage) GetClosestPrevBatch(roomID string, eventNID int64) (prevBatch string)

Nov 9, 2023

Changes in this version

type AccumulateResult

+ IncludesStateRedaction bool

type InvitesTable

+ func (t *InvitesTable) RemoveSupersededInvites(txn *sqlx.Tx, roomID string, newEvents []Event) error

type Storage

+ func (s *Storage) FetchMemberships(roomID string) (joins, invites, leaves []string, err error)

Oct 11, 2023

Changes in this version

+ type AccumulateResult struct

+ NumNew int

+ RequiresReload bool

+ TimelineNIDs []int64

type Event

+ MissingPrevious bool

type Storage

+ func (s *Storage) ResetMetadataState(metadata *internal.RoomMetadata) error

Sep 6, 2023

Changes in this version

type EventTable

+ func (t *EventTable) Redact(txn *sqlx.Tx, roomVer string, eventIDs []string) error

+ func (t *EventTable) SelectCreateEvent(txn *sqlx.Tx, roomID string) (json.RawMessage, error)

Aug 23, 2023

Changes in this version

type LatestEvents

+ func (e *LatestEvents) DiscardIgnoredMessages(shouldIgnore func(sender string) bool)

Aug 2, 2023

Changes in this version

type Storage

+ func (s *Storage) LatestEventNIDInRooms(roomIDs []string, highestNID int64) (roomToNID map[string]int64, err error)

Jul 12, 2023

Changes in this version

type Storage

+ func NewStorageWithDB(db *sqlx.DB) *Storage

Jun 19, 2023

Changes in this version

type EventTable

+ func (t *EventTable) LatestEventNIDInRooms(roomIDs []string, highestNID int64) (roomToNID map[string]int64, err error)

+ type LatestEvents struct

+ LatestNID int64

+ PrevBatch string

+ Timeline []json.RawMessage

type Storage

+ Accumulator *Accumulator

+ func (s *Storage) PrepareSnapshot(txn *sqlx.Tx) (tableName string, err error)

type ToDeviceRow

+ UserID string

Apr 27, 2023

Changes in this version

type DeviceDataTable

+ func (t *DeviceDataTable) DeleteDevice(userID, deviceID string) error

type EventTable

+ func (t *EventTable) SelectUnknownEventIDs(txn *sqlx.Tx, maybeUnknownEventIDs []string) (map[string]struct{}, error)

+ type InitialiseResult struct

+ AddedEvents bool

+ PrependTimelineEvents []json.RawMessage

+ SnapshotID int64

type ToDeviceTable

+ func (t *ToDeviceTable) DeleteAllMessagesForDevice(deviceID string) error

Feb 24, 2023

Changes in this version

+ func UnpackReceiptsFromEDU(roomID string, ephEvent json.RawMessage) (readReceipts, privateReceipts []internal.Receipt, err error)

Jan 12, 2023

Changes in this version

type AccountData

+ ID int64

type SnapshotRow

+ MembershipEvents pq.Int64Array

+ OtherEvents pq.Int64Array

Dec 16, 2022

Changes in this version

+ const AccountDataGlobalRoom

+ const ActionCancel

+ const ActionRequest

+ const EventsEnd

+ const EventsStart

+ const MaxPostgresParameters

+ const RelationMSpaceChild

+ const RelationMSpaceParent

+ func PackReceiptsIntoEDU(receipts []internal.Receipt) (json.RawMessage, error)

+ type AccountData struct

+ Data []byte

+ RoomID string

+ Type string

+ UserID string

+ type AccountDataChunker []AccountData

+ func (c AccountDataChunker) Len() int

+ func (c AccountDataChunker) Subslice(i, j int) sqlutil.Chunker

+ type AccountDataTable struct

+ func NewAccountDataTable(db *sqlx.DB) *AccountDataTable

+ func (t *AccountDataTable) Insert(txn *sqlx.Tx, accDatas []AccountData) ([]AccountData, error)

+ func (t *AccountDataTable) Select(txn *sqlx.Tx, userID string, eventTypes []string, roomID string) (datas []AccountData, err error)

+ func (t *AccountDataTable) SelectMany(txn *sqlx.Tx, userID string, roomIDs ...string) (datas []AccountData, err error)

+ func (t *AccountDataTable) SelectWithType(txn *sqlx.Tx, userID, evType string) (datas []AccountData, err error)

+ type Accumulator struct

+ func NewAccumulator(db *sqlx.DB) *Accumulator

+ func (a *Accumulator) Accumulate(roomID string, prevBatch string, timeline []json.RawMessage) (numNew int, timelineNIDs []int64, err error)

+ func (a *Accumulator) Delta(roomID string, lastEventNID int64, limit int) (eventsJSON []json.RawMessage, latest int64, err error)

+ func (a *Accumulator) Initialise(roomID string, state []json.RawMessage) (bool, int64, error)

+ type DeviceDataRow struct

+ Data []byte

+ DeviceID string

+ ID int64

+ UserID string

+ type DeviceDataTable struct

+ func NewDeviceDataTable(db *sqlx.DB) *DeviceDataTable

+ func (t *DeviceDataTable) Select(userID, deviceID string, swap bool) (dd *internal.DeviceData, err error)

+ func (t *DeviceDataTable) SelectFrom(pos int64) (results []internal.DeviceData, nextPos int64, err error)

+ func (t *DeviceDataTable) Upsert(dd *internal.DeviceData) (pos int64, err error)

+ type Event struct

+ BeforeStateSnapshotID int64

+ ID string

+ IsState bool

+ JSON []byte

+ Membership string

+ NID int64

+ PrevBatch sql.NullString

+ ReplacesNID int64

+ RoomID string

+ StateKey string

+ Type string

+ type EventChunker []Event

+ func (c EventChunker) Len() int

+ func (c EventChunker) Subslice(i, j int) sqlutil.Chunker

+ type EventTable struct

+ func NewEventTable(db *sqlx.DB) *EventTable

+ func (t *EventTable) Insert(txn *sqlx.Tx, events []Event, checkFields bool) (map[string]int, error)

+ func (t *EventTable) LatestEventInRooms(txn *sqlx.Tx, roomIDs []string, highestNID int64) (events []Event, err error)

+ func (t *EventTable) SelectByIDs(txn *sqlx.Tx, verifyAll bool, ids []string) (events []Event, err error)

+ func (t *EventTable) SelectByNIDs(txn *sqlx.Tx, verifyAll bool, nids []int64) (events []Event, err error)

+ func (t *EventTable) SelectClosestPrevBatch(roomID string, eventNID int64) (prevBatch string, err error)

+ func (t *EventTable) SelectClosestPrevBatchByID(roomID string, eventID string) (prevBatch string, err error)

+ func (t *EventTable) SelectEventNIDsWithTypeInRoom(txn *sqlx.Tx, eventType string, limit int, targetRoom string, ...) (eventNIDs []int64, err error)

+ func (t *EventTable) SelectEventsBetween(txn *sqlx.Tx, roomID string, lowerExclusive, upperInclusive int64, limit int) ([]Event, error)

+ func (t *EventTable) SelectEventsWithTypeStateKey(eventType, stateKey string, lowerExclusive, upperInclusive int64) ([]Event, error)

+ func (t *EventTable) SelectEventsWithTypeStateKeyInRooms(roomIDs []string, eventType, stateKey string, ...) ([]Event, error)

+ func (t *EventTable) SelectHighestNID() (highest int64, err error)

+ func (t *EventTable) SelectLatestEventsBetween(txn *sqlx.Tx, roomID string, lowerExclusive, upperInclusive int64, limit int) ([]Event, error)

+ func (t *EventTable) SelectNIDsByIDs(txn *sqlx.Tx, ids []string) (nids map[string]int64, err error)

+ func (t *EventTable) SelectStrippedEventsByIDs(txn *sqlx.Tx, verifyAll bool, ids []string) (StrippedEvents, error)

+ func (t *EventTable) SelectStrippedEventsByNIDs(txn *sqlx.Tx, verifyAll bool, nids []int64) (StrippedEvents, error)

+ func (t *EventTable) UpdateBeforeSnapshotID(txn *sqlx.Tx, eventNID, snapID, replacesNID int64) error

+ type InvitesTable struct

+ func NewInvitesTable(db *sqlx.DB) *InvitesTable

+ func (t *InvitesTable) InsertInvite(userID, roomID string, inviteRoomState []json.RawMessage) error

+ func (t *InvitesTable) RemoveInvite(userID, roomID string) error

+ func (t *InvitesTable) SelectAllInvitesForUser(userID string) (map[string][]json.RawMessage, error)

+ func (t *InvitesTable) SelectInviteState(userID, roomID string) (inviteState []json.RawMessage, err error)

+ type ReceiptChunker []internal.Receipt

+ func (c ReceiptChunker) Len() int

+ func (c ReceiptChunker) Subslice(i, j int) sqlutil.Chunker

+ type ReceiptTable struct

+ func NewReceiptTable(db *sqlx.DB) *ReceiptTable

+ func (t *ReceiptTable) Insert(roomID string, ephEvent json.RawMessage) (receipts []internal.Receipt, err error)

+ func (t *ReceiptTable) SelectReceiptsForEvents(roomID string, eventIDs []string) (receipts []internal.Receipt, err error)

+ func (t *ReceiptTable) SelectReceiptsForUser(roomID, userID string) (receipts []internal.Receipt, err error)

+ type RoomInfo struct

+ ID string

+ IsEncrypted bool

+ PredecessorRoomID *string

+ Type *string

+ UpgradedRoomID *string

+ type RoomsTable struct

+ func NewRoomsTable(db *sqlx.DB) *RoomsTable

+ func (t *RoomsTable) CurrentAfterSnapshotID(txn *sqlx.Tx, roomID string) (snapshotID int64, err error)

+ func (t *RoomsTable) LatestNIDs(txn *sqlx.Tx, roomIDs []string) (nids map[string]int64, err error)

+ func (t *RoomsTable) SelectRoomInfos(txn *sqlx.Tx) (infos []RoomInfo, err error)

+ func (t *RoomsTable) Upsert(txn *sqlx.Tx, info RoomInfo, snapshotID, latestNID int64) (err error)

+ type SnapshotRow struct

+ Events pq.Int64Array

+ RoomID string

+ SnapshotID int64

+ type SnapshotTable struct

+ func NewSnapshotsTable(db *sqlx.DB) *SnapshotTable

+ func (s *SnapshotTable) Delete(txn *sqlx.Tx, snapshotIDs []int64) error

+ func (s *SnapshotTable) Insert(txn *sqlx.Tx, row *SnapshotRow) error

+ func (s *SnapshotTable) Select(txn *sqlx.Tx, snapshotID int64) (row SnapshotRow, err error)

+ func (t *SnapshotTable) CurrentSnapshots(txn *sqlx.Tx) (map[string][]int64, error)

+ type SpaceRelation struct

+ Child string

+ IsSuggested bool

+ Ordering string

+ Parent string

+ Relation int

+ func NewSpaceRelationFromEvent(ev Event) (sr *SpaceRelation, isDeleted bool)

+ func (sr *SpaceRelation) Key() string

+ type SpaceRelationChunker []SpaceRelation

+ func (c SpaceRelationChunker) Len() int

+ func (c SpaceRelationChunker) Subslice(i, j int) sqlutil.Chunker

+ type SpacesTable struct

+ func NewSpacesTable(db *sqlx.DB) *SpacesTable

+ func (t *SpacesTable) BulkDelete(txn *sqlx.Tx, relations []SpaceRelation) error

+ func (t *SpacesTable) BulkInsert(txn *sqlx.Tx, relations []SpaceRelation) error

+ func (t *SpacesTable) HandleSpaceUpdates(txn *sqlx.Tx, events []Event) error

+ func (t *SpacesTable) SelectChildren(txn *sqlx.Tx, spaces []string) (map[string][]SpaceRelation, error)

+ type StartupSnapshot struct

+ AllJoinedMembers map[string][]string

+ GlobalMetadata map[string]internal.RoomMetadata

+ type Storage struct

+ AccountDataTable *AccountDataTable

+ DB *sqlx.DB

+ DeviceDataTable *DeviceDataTable

+ EventsTable *EventTable

+ InvitesTable *InvitesTable

+ ReceiptTable *ReceiptTable

+ ToDeviceTable *ToDeviceTable

+ TransactionsTable *TransactionsTable

+ UnreadTable *UnreadTable

+ func NewStorage(postgresURI string) *Storage

+ func (s *Storage) AccountData(userID, roomID string, eventTypes []string) (data []AccountData, err error)

+ func (s *Storage) AccountDatas(userID string, roomIDs ...string) (datas []AccountData, err error)

+ func (s *Storage) Accumulate(roomID, prevBatch string, timeline []json.RawMessage) (numNew int, timelineNIDs []int64, err error)

+ func (s *Storage) AllJoinedMembers(txn *sqlx.Tx) (map[string][]string, error)

+ func (s *Storage) EventNIDs(eventNIDs []int64) ([]json.RawMessage, error)

+ func (s *Storage) GlobalSnapshot() (ss StartupSnapshot, err error)

+ func (s *Storage) Initialise(roomID string, state []json.RawMessage) (bool, int64, error)

+ func (s *Storage) InsertAccountData(userID, roomID string, events []json.RawMessage) (data []AccountData, err error)

+ func (s *Storage) JoinedRoomsAfterPosition(userID string, pos int64) ([]string, error)

+ func (s *Storage) LatestEventNID() (int64, error)

+ func (s *Storage) LatestEventsInRooms(userID string, roomIDs []string, to int64, limit int) (map[string][]json.RawMessage, map[string]string, error)

+ func (s *Storage) MetadataForAllRooms(txn *sqlx.Tx) (map[string]internal.RoomMetadata, error)

+ func (s *Storage) RoomAccountDatasWithType(userID, eventType string) (data []AccountData, err error)

+ func (s *Storage) RoomMembershipDelta(roomID string, from, to int64, limit int) (eventJSON []json.RawMessage, upTo int64, err error)

+ func (s *Storage) RoomStateAfterEventPosition(ctx context.Context, roomIDs []string, pos int64, ...) (roomToEvents map[string][]Event, err error)

+ func (s *Storage) StateSnapshot(snapID int64) (state []json.RawMessage, err error)

+ func (s *Storage) Teardown()

+ func (s *Storage) VisibleEventNIDsBetween(userID string, from, to int64) (map[string][][2]int64, error)

+ type StrippedEvents []Event

+ func (se StrippedEvents) NIDs() (result []int64)

+ type ToDeviceRow struct

+ Action int

+ DeviceID string

+ Message string

+ Position int64

+ Sender string

+ Type string

+ UniqueKey *string

+ type ToDeviceRowChunker []ToDeviceRow

+ func (c ToDeviceRowChunker) Len() int

+ func (c ToDeviceRowChunker) Subslice(i, j int) sqlutil.Chunker

+ type ToDeviceTable struct

+ func NewToDeviceTable(db *sqlx.DB) *ToDeviceTable

+ func (t *ToDeviceTable) DeleteMessagesUpToAndIncluding(deviceID string, toIncl int64) error

+ func (t *ToDeviceTable) InsertMessages(deviceID string, msgs []json.RawMessage) (pos int64, err error)

+ func (t *ToDeviceTable) Messages(deviceID string, from, limit int64) (msgs []json.RawMessage, upTo int64, err error)

+ func (t *ToDeviceTable) SetUnackedPosition(deviceID string, pos int64) error

+ type TransactionsTable struct

+ func NewTransactionsTable(db *sqlx.DB) *TransactionsTable

+ func (t *TransactionsTable) Clean(boundaryTime time.Time) error

+ func (t *TransactionsTable) Insert(userID string, eventIDToTxnID map[string]string) error

+ func (t *TransactionsTable) Select(userID string, eventIDs []string) (map[string]string, error)

+ type TypingTable struct

+ func NewTypingTable(db *sqlx.DB) *TypingTable

+ func (t *TypingTable) SelectHighestID() (id int64, err error)

+ func (t *TypingTable) SetTyping(roomID string, userIDs []string) (position int64, err error)

+ func (t *TypingTable) Typing(roomID string, fromStreamIDExcl, toStreamIDIncl int64) (userIDs []string, latest int64, err error)

+ type UnreadTable struct

+ func NewUnreadTable(db *sqlx.DB) *UnreadTable

+ func (t *UnreadTable) SelectAllNonZeroCountsForUser(userID string, ...) error

+ func (t *UnreadTable) SelectUnreadCounters(userID, roomID string) (highlightCount, notificationCount int, err error)

+ func (t *UnreadTable) UpdateUnreadCounters(userID, roomID string, highlightCount, notificationCount *int) error