synapse-old/synapse/storage/stream.py

949 lines
32 KiB
Python
Raw Normal View History

2014-08-12 08:10:52 -06:00
# -*- coding: utf-8 -*-
2016-01-06 21:26:29 -07:00
# Copyright 2014-2016 OpenMarket Ltd
2014-08-12 08:10:52 -06:00
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
""" This module is responsible for getting events from the DB for pagination
and event streaming.
The order it returns events in depend on whether we are streaming forwards or
are paginating backwards. We do this because we want to handle out of order
messages nicely, while still returning them in the correct order when we
paginate bacwards.
This is implemented by keeping two ordering columns: stream_ordering and
topological_ordering. Stream ordering is basically insertion/received order
2015-10-28 07:45:56 -06:00
(except for events from backfill requests). The topological_ordering is a
weak ordering of events based on the pdu graph.
This means that we have to have two different types of tokens, depending on
what sort order was used:
- stream tokens are of the form: "s%d", which maps directly to the column
- topological tokems: "t%d-%d", where the integers map to the topological
and stream ordering columns respectively.
"""
2018-07-09 00:09:20 -06:00
import abc
import logging
from collections import namedtuple
from six.moves import range
2014-08-14 11:40:50 -06:00
from twisted.internet import defer
from synapse.logging.context import make_deferred_yieldable, run_in_background
2018-03-01 06:56:03 -07:00
from synapse.storage._base import SQLBaseStore
2018-07-09 00:09:20 -06:00
from synapse.storage.engines import PostgresEngine
from synapse.storage.events_worker import EventsWorkerStore
from synapse.types import RoomStreamToken
2018-03-01 06:56:03 -07:00
from synapse.util.caches.stream_change_cache import StreamChangeCache
2014-08-12 08:10:52 -06:00
2014-08-14 11:01:39 -06:00
logger = logging.getLogger(__name__)
2014-08-12 08:10:52 -06:00
2014-08-14 11:01:39 -06:00
MAX_STREAM_SIZE = 1000
2014-08-12 08:10:52 -06:00
_STREAM_TOKEN = "stream"
_TOPOLOGICAL_TOKEN = "topological"
# Used as return values for pagination APIs
_EventDictReturn = namedtuple(
"_EventDictReturn", ("event_id", "topological_ordering", "stream_ordering")
)
def generate_pagination_where_clause(
2019-06-20 03:32:02 -06:00
direction, column_names, from_token, to_token, engine
):
"""Creates an SQL expression to bound the columns by the pagination
tokens.
For example creates an SQL expression like:
(6, 7) >= (topological_ordering, stream_ordering)
AND (5, 3) < (topological_ordering, stream_ordering)
would be generated for dir=b, from_token=(6, 7) and to_token=(5, 3).
2019-05-16 09:41:05 -06:00
Note that tokens are considered to be after the row they are in, e.g. if
2019-05-17 09:40:51 -06:00
a row A has a token T, then we consider A to be before T. This convention
2019-05-16 09:41:05 -06:00
is important when figuring out inequalities for the generated SQL, and
produces the following result:
2019-05-17 09:40:51 -06:00
- If paginating forwards then we exclude any rows matching the from
2019-05-16 09:41:05 -06:00
token, but include those that match the to token.
2019-05-17 09:40:51 -06:00
- If paginating backwards then we include any rows matching the from
2019-05-16 09:41:05 -06:00
token, but include those that match the to token.
Args:
direction (str): Whether we're paginating backwards("b") or
forwards ("f").
column_names (tuple[str, str]): The column names to bound. Must *not*
be user defined as these get inserted directly into the SQL
statement without escapes.
2019-05-17 09:40:51 -06:00
from_token (tuple[int, int]|None): The start point for the pagination.
This is an exclusive minimum bound if direction is "f", and an
inclusive maximum bound if direction is "b".
to_token (tuple[int, int]|None): The endpoint point for the pagination.
This is an inclusive maximum bound if direction is "f", and an
exclusive minimum bound if direction is "b".
engine: The database engine to generate the clauses for
Returns:
str: The sql expression
"""
assert direction in ("b", "f")
where_clause = []
if from_token:
where_clause.append(
_make_generic_sql_bound(
bound=">=" if direction == "b" else "<",
column_names=column_names,
values=from_token,
engine=engine,
)
)
2015-01-13 07:14:21 -07:00
if to_token:
where_clause.append(
_make_generic_sql_bound(
bound="<" if direction == "b" else ">=",
column_names=column_names,
values=to_token,
engine=engine,
)
)
return " AND ".join(where_clause)
def _make_generic_sql_bound(bound, column_names, values, engine):
"""Create an SQL expression that bounds the given column names by the
values, e.g. create the equivalent of `(1, 2) < (col1, col2)`.
Only works with two columns.
Older versions of SQLite don't support that syntax so we have to expand it
out manually.
Args:
bound (str): The comparison operator to use. One of ">", "<", ">=",
"<=", where the values are on the left and columns on the right.
names (tuple[str, str]): The column names. Must *not* be user defined
as these get inserted directly into the SQL statement without
escapes.
2019-05-16 09:41:05 -06:00
values (tuple[int|None, int]): The values to bound the columns by. If
the first value is None then only creates a bound on the second
column.
engine: The database engine to generate the SQL for
Returns:
str
"""
2019-06-20 03:32:02 -06:00
assert bound in (">", "<", ">=", "<=")
name1, name2 = column_names
val1, val2 = values
if val1 is None:
val2 = int(val2)
return "(%d %s %s)" % (val2, bound, name2)
val1 = int(val1)
val2 = int(val2)
if isinstance(engine, PostgresEngine):
# Postgres doesn't optimise ``(x < a) OR (x=a AND y<b)`` as well
# as it optimises ``(x,y) < (a,b)`` on multicolumn indexes. So we
# use the later form when running against postgres.
2019-06-20 03:32:02 -06:00
return "((%d,%d) %s (%s,%s))" % (val1, val2, bound, name1, name2)
# We want to generate queries of e.g. the form:
#
# (val1 < name1 OR (val1 = name1 AND val2 <= name2))
#
# which is equivalent to (val1, val2) < (name1, name2)
return """(
{val1:d} {strict_bound} {name1}
OR ({val1:d} = {name1} AND {val2:d} {bound} {name2})
)""".format(
name1=name1,
val1=val1,
name2=name2,
val2=val2,
strict_bound=bound[0], # The first bound must always be strict equality here
bound=bound,
)
def filter_to_clause(event_filter):
2016-07-20 03:18:09 -06:00
# NB: This may create SQL clauses that don't optimise well (and we don't
# have indices on all possible clauses). E.g. it may create
# "room_id == X AND room_id != X", which postgres doesn't optimise.
if not event_filter:
return "", []
clauses = []
args = []
if event_filter.types:
clauses.append("(%s)" % " OR ".join("type = ?" for _ in event_filter.types))
args.extend(event_filter.types)
for typ in event_filter.not_types:
clauses.append("type != ?")
args.append(typ)
if event_filter.senders:
clauses.append("(%s)" % " OR ".join("sender = ?" for _ in event_filter.senders))
args.extend(event_filter.senders)
for sender in event_filter.not_senders:
clauses.append("sender != ?")
args.append(sender)
if event_filter.rooms:
clauses.append("(%s)" % " OR ".join("room_id = ?" for _ in event_filter.rooms))
args.extend(event_filter.rooms)
for room_id in event_filter.not_rooms:
clauses.append("room_id != ?")
args.append(room_id)
if event_filter.contains_url:
clauses.append("contains_url = ?")
args.append(event_filter.contains_url)
return " AND ".join(clauses), args
2018-03-01 06:56:03 -07:00
class StreamWorkerStore(EventsWorkerStore, SQLBaseStore):
"""This is an abstract base class where subclasses must implement
`get_room_max_stream_ordering` and `get_room_min_stream_ordering`
which can be called in the initializer.
"""
2018-03-01 06:56:03 -07:00
__metaclass__ = abc.ABCMeta
2018-03-01 06:56:03 -07:00
def __init__(self, db_conn, hs):
super(StreamWorkerStore, self).__init__(db_conn, hs)
2018-03-01 06:56:03 -07:00
events_max = self.get_room_max_stream_ordering()
event_cache_prefill, min_event_val = self._get_cache_dict(
db_conn,
"events",
2018-03-01 06:56:03 -07:00
entity_column="room_id",
stream_column="stream_ordering",
max_value=events_max,
)
self._events_stream_cache = StreamChangeCache(
"EventsRoomStreamChangeCache",
min_event_val,
2018-03-01 06:56:03 -07:00
prefilled_cache=event_cache_prefill,
)
self._membership_stream_cache = StreamChangeCache(
"MembershipStreamChangeCache", events_max
2016-06-03 10:12:48 -06:00
)
2018-03-01 06:56:03 -07:00
self._stream_order_on_start = self.get_room_max_stream_ordering()
@abc.abstractmethod
def get_room_max_stream_ordering(self):
raise NotImplementedError()
@abc.abstractmethod
def get_room_min_stream_ordering(self):
raise NotImplementedError()
2016-01-27 02:54:30 -07:00
@defer.inlineCallbacks
def get_room_events_stream_for_rooms(
2019-06-20 03:32:02 -06:00
self, room_ids, from_key, to_key, limit=0, order="DESC"
):
"""Get new room events in stream ordering since `from_key`.
Args:
room_id (str)
from_key (str): Token from which no events are returned before
to_key (str): Token from which no events are returned after. (This
is typically the current stream token)
limit (int): Maximum number of events to return
order (str): Either "DESC" or "ASC". Determines which events are
returned when the result is limited. If "DESC" then the most
recent `limit` events are returned, otherwise returns the
oldest `limit` events.
Returns:
Deferred[dict[str,tuple[list[FrozenEvent], str]]]
A map from room id to a tuple containing:
- list of recent events in the room
- stream ordering key for the start of the chunk of events returned.
"""
2016-01-27 02:54:30 -07:00
from_id = RoomStreamToken.parse_stream_token(from_key).stream
2016-01-28 09:37:41 -07:00
room_ids = yield self._events_stream_cache.get_entities_changed(
room_ids, from_id
2016-01-27 02:54:30 -07:00
)
if not room_ids:
return {}
2016-01-27 02:54:30 -07:00
results = {}
room_ids = list(room_ids)
for rm_ids in (room_ids[i : i + 20] for i in range(0, len(room_ids), 20)):
res = yield make_deferred_yieldable(
defer.gatherResults(
[
run_in_background(
self.get_room_events_stream_for_room,
room_id,
from_key,
to_key,
limit,
order=order,
)
for room_id in rm_ids
],
consumeErrors=True,
2016-02-04 03:22:44 -07:00
)
)
2016-02-04 03:22:44 -07:00
results.update(dict(zip(rm_ids, res)))
2016-01-27 02:54:30 -07:00
return results
2016-01-27 02:54:30 -07:00
def get_rooms_that_changed(self, room_ids, from_key):
2017-02-01 10:35:23 -07:00
"""Given a list of rooms and a token, return rooms where there may have
been changes.
2017-02-01 10:52:57 -07:00
Args:
room_ids (list)
from_key (str): The room_key portion of a StreamToken
2017-02-01 10:35:23 -07:00
"""
from_key = RoomStreamToken.parse_stream_token(from_key).stream
return set(
room_id
for room_id in room_ids
if self._events_stream_cache.has_entity_changed(room_id, from_key)
)
2016-01-27 02:54:30 -07:00
@defer.inlineCallbacks
def get_room_events_stream_for_room(
2019-06-20 03:32:02 -06:00
self, room_id, from_key, to_key, limit=0, order="DESC"
):
2016-01-27 02:54:30 -07:00
"""Get new room events in stream ordering since `from_key`.
Args:
room_id (str)
from_key (str): Token from which no events are returned before
to_key (str): Token from which no events are returned after. (This
is typically the current stream token)
limit (int): Maximum number of events to return
order (str): Either "DESC" or "ASC". Determines which events are
returned when the result is limited. If "DESC" then the most
recent `limit` events are returned, otherwise returns the
oldest `limit` events.
Returns:
Deferred[tuple[list[FrozenEvent], str]]: Returns the list of
events (in ascending order) and the token from the start of
the chunk of events returned.
"""
2016-01-27 02:54:30 -07:00
if from_key == to_key:
return [], from_key
2016-01-27 02:54:30 -07:00
from_id = RoomStreamToken.parse_stream_token(from_key).stream
to_id = RoomStreamToken.parse_stream_token(to_key).stream
2016-01-27 02:54:30 -07:00
has_changed = yield self._events_stream_cache.has_entity_changed(
room_id, from_id
)
2016-01-27 02:54:30 -07:00
if not has_changed:
return [], from_key
2016-01-27 02:54:30 -07:00
def f(txn):
sql = (
"SELECT event_id, stream_ordering FROM events WHERE"
" room_id = ?"
" AND not outlier"
" AND stream_ordering > ? AND stream_ordering <= ?"
" ORDER BY stream_ordering %s LIMIT ?"
) % (order,)
txn.execute(sql, (room_id, from_id, to_id, limit))
2016-01-27 02:54:30 -07:00
rows = [_EventDictReturn(row[0], None, row[1]) for row in txn]
return rows
2016-01-27 02:54:30 -07:00
rows = yield self.runInteraction("get_room_events_stream_for_room", f)
2016-01-27 02:54:30 -07:00
2019-06-20 03:32:02 -06:00
ret = yield self.get_events_as_list(
[r.event_id for r in rows], get_prev_content=True
)
2016-03-09 09:11:53 -07:00
self._set_before_and_after(ret, rows, topo_order=from_id is None)
2016-01-27 02:54:30 -07:00
if order.lower() == "desc":
ret.reverse()
2016-01-27 02:54:30 -07:00
if rows:
key = "s%d" % min(r.stream_ordering for r in rows)
else:
# Assume we didn't get anything because there was nothing to
# get.
key = from_key
return ret, key
@defer.inlineCallbacks
def get_membership_changes_for_user(self, user_id, from_key, to_key):
from_id = RoomStreamToken.parse_stream_token(from_key).stream
2016-01-27 02:54:30 -07:00
to_id = RoomStreamToken.parse_stream_token(to_key).stream
if from_key == to_key:
return []
2016-01-27 02:54:30 -07:00
2016-01-29 09:52:48 -07:00
if from_id:
has_changed = self._membership_stream_cache.has_entity_changed(
user_id, int(from_id)
)
if not has_changed:
return []
2016-01-29 09:52:48 -07:00
2016-01-27 02:54:30 -07:00
def f(txn):
sql = (
"SELECT m.event_id, stream_ordering FROM events AS e,"
" room_memberships AS m"
" WHERE e.event_id = m.event_id"
" AND m.user_id = ?"
" AND e.stream_ordering > ? AND e.stream_ordering <= ?"
" ORDER BY e.stream_ordering ASC"
)
txn.execute(sql, (user_id, from_id, to_id))
rows = [_EventDictReturn(row[0], None, row[1]) for row in txn]
2016-01-27 02:54:30 -07:00
return rows
2016-01-27 02:54:30 -07:00
rows = yield self.runInteraction("get_membership_changes_for_user", f)
ret = yield self.get_events_as_list(
2019-06-20 03:32:02 -06:00
[r.event_id for r in rows], get_prev_content=True
)
self._set_before_and_after(ret, rows, topo_order=False)
2016-01-27 02:54:30 -07:00
return ret
2016-01-27 02:54:30 -07:00
@defer.inlineCallbacks
2018-05-09 03:58:16 -06:00
def get_recent_events_for_room(self, room_id, limit, end_token):
"""Get the most recent events in the room in topological ordering.
Args:
room_id (str)
limit (int)
end_token (str): The stream token representing now.
Returns:
Deferred[tuple[list[FrozenEvent], str]]: Returns a list of
2018-05-09 08:42:39 -06:00
events and a token pointing to the start of the returned
events.
The events returned are in ascending order.
"""
rows, token = yield self.get_recent_event_ids_for_room(
room_id, limit, end_token
)
logger.debug("stream before")
events = yield self.get_events_as_list(
[r.event_id for r in rows], get_prev_content=True
)
logger.debug("stream after")
self._set_before_and_after(events, rows)
return (events, token)
@defer.inlineCallbacks
2018-05-09 03:58:16 -06:00
def get_recent_event_ids_for_room(self, room_id, limit, end_token):
"""Get the most recent events in the room in topological ordering.
Args:
room_id (str)
limit (int)
end_token (str): The stream token representing now.
Returns:
Deferred[tuple[list[_EventDictReturn], str]]: Returns a list of
2018-05-09 08:15:38 -06:00
_EventDictReturn and a token pointing to the start of the returned
events.
The events returned are in ascending order.
"""
# Allow a zero limit here, and no-op.
if limit == 0:
return [], end_token
end_token = RoomStreamToken.parse(end_token)
rows, token = yield self.runInteraction(
"get_recent_event_ids_for_room",
self._paginate_room_events_txn,
room_id,
from_token=end_token,
limit=limit,
)
# We want to return the results in ascending order.
rows.reverse()
return rows, token
def get_room_event_after_stream_ordering(self, room_id, stream_ordering):
"""Gets details of the first event in a room at or after a stream ordering
Args:
room_id (str):
stream_ordering (int):
Returns:
Deferred[(int, int, str)]:
(stream ordering, topological ordering, event_id)
"""
def _f(txn):
sql = (
"SELECT stream_ordering, topological_ordering, event_id"
" FROM events"
" WHERE room_id = ? AND stream_ordering >= ?"
" AND NOT outlier"
" ORDER BY stream_ordering"
" LIMIT 1"
)
txn.execute(sql, (room_id, stream_ordering))
return txn.fetchone()
return self.runInteraction("get_room_event_after_stream_ordering", _f)
@defer.inlineCallbacks
def get_room_events_max_id(self, room_id=None):
"""Returns the current token for rooms stream.
By default, it returns the current global stream token. Specifying a
`room_id` causes it to return the current room specific topological
token.
"""
2018-03-01 06:56:03 -07:00
token = yield self.get_room_max_stream_ordering()
if room_id is None:
return "s%d" % (token,)
else:
topo = yield self.runInteraction(
"_get_max_topological_txn", self._get_max_topological_txn, room_id
)
return "t%d-%d" % (topo, token)
def get_stream_token_for_event(self, event_id):
"""The stream token for an event
Args:
event_id(str): The id of the event to look up a stream token for.
Raises:
StoreError if the event wasn't in the database.
Returns:
A deferred "s%d" stream token.
"""
return self._simple_select_one_onecol(
table="events", keyvalues={"event_id": event_id}, retcol="stream_ordering"
).addCallback(lambda row: "s%d" % (row,))
def get_topological_token_for_event(self, event_id):
"""The stream token for an event
Args:
event_id(str): The id of the event to look up a stream token for.
Raises:
StoreError if the event wasn't in the database.
Returns:
A deferred "t%d-%d" topological token.
"""
return self._simple_select_one(
table="events",
keyvalues={"event_id": event_id},
retcols=("stream_ordering", "topological_ordering"),
2016-02-03 09:22:35 -07:00
desc="get_topological_token_for_event",
).addCallback(
lambda row: "t%d-%d" % (row["topological_ordering"], row["stream_ordering"])
)
def get_max_topological_token(self, room_id, stream_key):
2019-06-06 04:09:38 -06:00
"""Get the max topological token in a room before the given stream
ordering.
Args:
room_id (str)
stream_key (int)
Returns:
Deferred[int]
"""
sql = (
"SELECT coalesce(max(topological_ordering), 0) FROM events"
" WHERE room_id = ? AND stream_ordering < ?"
)
return self._execute(
"get_max_topological_token", None, sql, room_id, stream_key
).addCallback(lambda r: r[0][0] if r else 0)
def _get_max_topological_txn(self, txn, room_id):
txn.execute(
"SELECT MAX(topological_ordering) FROM events" " WHERE room_id = ?",
(room_id,),
)
rows = txn.fetchall()
return rows[0][0] if rows else 0
@staticmethod
2016-01-28 04:34:17 -07:00
def _set_before_and_after(events, rows, topo_order=True):
"""Inserts ordering information to events' internal metadata from
the DB rows.
Args:
events (list[FrozenEvent])
rows (list[_EventDictReturn])
topo_order (bool): Whether the events were ordered topologically
2018-05-09 08:15:38 -06:00
or by stream ordering. If true then all rows should have a non
null topological_ordering.
"""
for event, row in zip(events, rows):
stream = row.stream_ordering
if topo_order and row.topological_ordering:
topo = row.topological_ordering
2016-01-28 04:34:17 -07:00
else:
topo = None
internal = event.internal_metadata
internal.before = str(RoomStreamToken(topo, stream - 1))
internal.after = str(RoomStreamToken(topo, stream))
internal.order = (int(topo) if topo else 0, int(stream))
2015-10-28 07:45:56 -06:00
@defer.inlineCallbacks
def get_events_around(
self, room_id, event_id, before_limit, after_limit, event_filter=None
):
2015-10-28 08:05:50 -06:00
"""Retrieve events and pagination tokens around a given event in a
room.
Args:
room_id (str)
event_id (str)
before_limit (int)
after_limit (int)
event_filter (Filter|None)
2015-10-28 08:05:50 -06:00
Returns:
dict
"""
2015-10-28 07:45:56 -06:00
results = yield self.runInteraction(
"get_events_around",
self._get_events_around_txn,
room_id,
event_id,
before_limit,
after_limit,
event_filter,
2015-10-28 07:45:56 -06:00
)
events_before = yield self.get_events_as_list(
[e for e in results["before"]["event_ids"]], get_prev_content=True
2015-10-28 07:45:56 -06:00
)
events_after = yield self.get_events_as_list(
[e for e in results["after"]["event_ids"]], get_prev_content=True
2015-10-28 07:45:56 -06:00
)
return {
"events_before": events_before,
"events_after": events_after,
"start": results["before"]["token"],
"end": results["after"]["token"],
}
2015-10-28 07:45:56 -06:00
def _get_events_around_txn(
self, txn, room_id, event_id, before_limit, after_limit, event_filter
):
2015-10-28 08:05:50 -06:00
"""Retrieves event_ids and pagination tokens around a given event in a
room.
Args:
room_id (str)
event_id (str)
before_limit (int)
after_limit (int)
event_filter (Filter|None)
2015-10-28 08:05:50 -06:00
Returns:
dict
"""
2015-10-28 07:45:56 -06:00
results = self._simple_select_one_txn(
txn,
"events",
keyvalues={"event_id": event_id, "room_id": room_id},
2015-10-28 07:45:56 -06:00
retcols=["stream_ordering", "topological_ordering"],
)
# Paginating backwards includes the event at the token, but paginating
# forward doesn't.
before_token = RoomStreamToken(
results["topological_ordering"] - 1, results["stream_ordering"]
2015-10-28 07:45:56 -06:00
)
after_token = RoomStreamToken(
results["topological_ordering"], results["stream_ordering"]
)
2015-10-28 07:45:56 -06:00
rows, start_token = self._paginate_room_events_txn(
txn,
room_id,
before_token,
2019-06-20 03:32:02 -06:00
direction="b",
limit=before_limit,
event_filter=event_filter,
)
events_before = [r.event_id for r in rows]
2015-10-28 07:45:56 -06:00
rows, end_token = self._paginate_room_events_txn(
txn,
room_id,
after_token,
2019-06-20 03:32:02 -06:00
direction="f",
limit=after_limit,
event_filter=event_filter,
)
events_after = [r.event_id for r in rows]
2015-10-28 07:45:56 -06:00
return {
"before": {"event_ids": events_before, "token": start_token},
"after": {"event_ids": events_after, "token": end_token},
2015-10-28 07:45:56 -06:00
}
@defer.inlineCallbacks
def get_all_new_events_stream(self, from_id, current_id, limit):
"""Get all new events
Returns all events with from_id < stream_ordering <= current_id.
Args:
from_id (int): the stream_ordering of the last event we processed
current_id (int): the stream_ordering of the most recently processed event
limit (int): the maximum number of events to return
Returns:
Deferred[Tuple[int, list[FrozenEvent]]]: A tuple of (next_id, events), where
`next_id` is the next value to pass as `from_id` (it will either be the
stream_ordering of the last returned event, or, if fewer than `limit` events
were found, `current_id`.
"""
def get_all_new_events_stream_txn(txn):
sql = (
"SELECT e.stream_ordering, e.event_id"
" FROM events AS e"
" WHERE"
" ? < e.stream_ordering AND e.stream_ordering <= ?"
" ORDER BY e.stream_ordering ASC"
" LIMIT ?"
)
txn.execute(sql, (from_id, current_id, limit))
rows = txn.fetchall()
upper_bound = current_id
if len(rows) == limit:
upper_bound = rows[-1][0]
return upper_bound, [row[1] for row in rows]
upper_bound, event_ids = yield self.runInteraction(
"get_all_new_events_stream", get_all_new_events_stream_txn
)
events = yield self.get_events_as_list(event_ids)
return upper_bound, events
def get_federation_out_pos(self, typ):
return self._simple_select_one_onecol(
table="federation_stream_position",
retcol="stream_id",
keyvalues={"type": typ},
desc="get_federation_out_pos",
)
def update_federation_out_pos(self, typ, stream_id):
return self._simple_update_one(
table="federation_stream_position",
keyvalues={"type": typ},
updatevalues={"stream_id": stream_id},
desc="update_federation_out_pos",
)
2017-03-13 03:50:10 -06:00
def has_room_changed_since(self, room_id, stream_id):
return self._events_stream_cache.has_entity_changed(room_id, stream_id)
2018-03-01 06:56:03 -07:00
def _paginate_room_events_txn(
self,
txn,
room_id,
from_token,
to_token=None,
2019-06-20 03:32:02 -06:00
direction="b",
limit=-1,
event_filter=None,
):
"""Returns list of events before or after a given token.
2018-03-01 06:56:03 -07:00
Args:
txn
room_id (str)
from_token (RoomStreamToken): The token used to stream from
to_token (RoomStreamToken|None): A token which if given limits the
results to only those before
direction(char): Either 'b' or 'f' to indicate whether we are
paginating forwards or backwards from `from_key`.
limit (int): The maximum number of events to return.
event_filter (Filter|None): If provided filters the events to
those that match the filter.
2018-03-01 06:56:03 -07:00
Returns:
2018-05-09 08:15:38 -06:00
Deferred[tuple[list[_EventDictReturn], str]]: Returns the results
as a list of _EventDictReturn and a token that points to the end
of the result set. If no events are returned then the end of the
stream has been reached (i.e. there are no events between
2019-07-12 09:59:59 -06:00
`from_token` and `to_token`), or `limit` is zero.
"""
assert int(limit) >= 0
2018-03-01 06:56:03 -07:00
# Tokens really represent positions between elements, but we use
# the convention of pointing to the event before the gap. Hence
# we have a bit of asymmetry when it comes to equalities.
args = [False, room_id]
2019-06-20 03:32:02 -06:00
if direction == "b":
2018-03-01 06:56:03 -07:00
order = "DESC"
else:
order = "ASC"
bounds = generate_pagination_where_clause(
direction=direction,
column_names=("topological_ordering", "stream_ordering"),
from_token=from_token,
to_token=to_token,
engine=self.database_engine,
)
2018-03-01 06:56:03 -07:00
filter_clause, filter_args = filter_to_clause(event_filter)
if filter_clause:
bounds += " AND " + filter_clause
args.extend(filter_args)
args.append(int(limit))
2018-03-01 06:56:03 -07:00
sql = (
"SELECT event_id, topological_ordering, stream_ordering"
" FROM events"
2018-03-01 06:56:03 -07:00
" WHERE outlier = ? AND room_id = ? AND %(bounds)s"
" ORDER BY topological_ordering %(order)s,"
" stream_ordering %(order)s LIMIT ?"
) % {"bounds": bounds, "order": order}
2018-03-01 06:56:03 -07:00
txn.execute(sql, args)
2018-03-01 06:56:03 -07:00
rows = [_EventDictReturn(row[0], row[1], row[2]) for row in txn]
2018-03-01 06:56:03 -07:00
if rows:
topo = rows[-1].topological_ordering
toke = rows[-1].stream_ordering
2019-06-20 03:32:02 -06:00
if direction == "b":
# Tokens are positions between events.
# This token points *after* the last event in the chunk.
# We need it to point to the event before it in the chunk
# when we are going backwards so we subtract one from the
# stream part.
toke -= 1
next_token = RoomStreamToken(topo, toke)
else:
# TODO (erikj): We should work out what to do here instead.
next_token = to_token if to_token else from_token
return rows, str(next_token)
2018-03-01 06:56:03 -07:00
@defer.inlineCallbacks
def paginate_room_events(
2019-06-20 03:32:02 -06:00
self, room_id, from_key, to_key=None, direction="b", limit=-1, event_filter=None
):
"""Returns list of events before or after a given token.
2018-03-01 06:56:03 -07:00
Args:
room_id (str)
from_key (str): The token used to stream from
to_key (str|None): A token which if given limits the results to
only those before
direction(char): Either 'b' or 'f' to indicate whether we are
paginating forwards or backwards from `from_key`.
limit (int): The maximum number of events to return.
event_filter (Filter|None): If provided filters the events to
those that match the filter.
Returns:
2019-07-12 09:59:59 -06:00
tuple[list[FrozenEvent], str]: Returns the results as a list of
events and a token that points to the end of the result set. If no
events are returned then the end of the stream has been reached
(i.e. there are no events between `from_key` and `to_key`).
"""
from_key = RoomStreamToken.parse(from_key)
if to_key:
to_key = RoomStreamToken.parse(to_key)
rows, token = yield self.runInteraction(
"paginate_room_events",
self._paginate_room_events_txn,
room_id,
from_key,
to_key,
direction,
limit,
event_filter,
)
2018-03-01 06:56:03 -07:00
events = yield self.get_events_as_list(
[r.event_id for r in rows], get_prev_content=True
2018-03-01 06:56:03 -07:00
)
self._set_before_and_after(events, rows)
return (events, token)
class StreamStore(StreamWorkerStore):
def get_room_max_stream_ordering(self):
return self._stream_id_gen.get_current_token()
def get_room_min_stream_ordering(self):
return self._backfill_id_gen.get_current_token()