diff --git a/synapse/storage/state.py b/synapse/storage/state.py
index 89a05c4618..c5ff44fef7 100644
--- a/synapse/storage/state.py
+++ b/synapse/storage/state.py
@@ -186,7 +186,19 @@ class StateGroupWorkerStore(SQLBaseStore):
@defer.inlineCallbacks
def _get_state_groups_from_groups(self, groups, types):
- """Returns dictionary state_group -> (dict of (type, state_key) -> event id)
+ """Returns the state groups for a given set of groups, filtering on
+ types of state events.
+
+ Args:
+ groups(list[int]): list of state group IDs to query
+ types(list[str|None, str|None])|None: List of 2-tuples of the form
+ (`type`, `state_key`), where a `state_key` of `None` matches all
+ state_keys for the `type`. Presence of type of `None` indicates
+ that types not in the list should not be filtered out. If None,
+ all types are returned.
+
+ Returns:
+ dictionary state_group -> (dict of (type, state_key) -> event id)
"""
results = {}
@@ -202,8 +214,18 @@ class StateGroupWorkerStore(SQLBaseStore):
def _get_state_groups_from_groups_txn(self, txn, groups, types=None):
results = {group: {} for group in groups}
+
+ include_other_types = False
+
if types is not None:
- types = list(set(types)) # deduplicate types list
+ type_set = set(types)
+ if (None, None) in type_set:
+ # special case (None, None) to mean that other types should be
+ # returned - i.e. we were just filtering down the state keys
+ # for particular types.
+ include_other_types = True
+ type_set.remove((None, None))
+ types = list(type_set) # deduplicate types list
if isinstance(self.database_engine, PostgresEngine):
# Temporarily disable sequential scans in this transaction. This is
@@ -250,6 +272,17 @@ class StateGroupWorkerStore(SQLBaseStore):
)
for etype, state_key in types
]
+
+ if include_other_types:
+ # XXX: check whether this slows postgres down like a list of
+ # ORs does too?
+ unique_types = set([t for (t, _) in types])
+ clause_to_args.append(
+ (
+ "AND type <> ? " * len(unique_types),
+ list(unique_types)
+ )
+ )
else:
# If types is None we fetch all the state, and so just use an
# empty where clause with no extra args.
@@ -278,6 +311,14 @@ class StateGroupWorkerStore(SQLBaseStore):
else:
where_clauses.append("(type = ? AND state_key = ?)")
where_args.extend([typ[0], typ[1]])
+
+ if include_other_types:
+ unique_types = set([t for (t, _) in types])
+ where_clauses.append(
+ "(" + " AND ".join(["type <> ?"] * len(unique_types)) + ")"
+ )
+ where_args.extend(list(unique_types))
+
where_clause = "AND (%s)" % (" OR ".join(where_clauses))
else:
where_clause = ""
@@ -338,10 +379,12 @@ class StateGroupWorkerStore(SQLBaseStore):
that are in the `types` list.
Args:
- event_ids (list)
- types (list): List of (type, state_key) tuples which are used to
- filter the state fetched. `state_key` may be None, which matches
- any `state_key`
+ event_ids (list[string])
+ types (list[(str|None, str|None)]|None): List of (type, state_key) tuples
+ which are used to filter the state fetched. If `state_key` is None,
+ all events are returned of the given type. Presence of type of `None`
+ indicates that types not in the list should not be filtered out.
+ May be None, which matches any key.
Returns:
deferred: A list of dicts corresponding to the event_ids given.
@@ -377,9 +420,11 @@ class StateGroupWorkerStore(SQLBaseStore):
Args:
event_ids(list(str)): events whose state should be returned
- types(list[(str, str)]|None): List of (type, state_key) tuples
- which are used to filter the state fetched. May be None, which
- matches any key
+ types(list[(str|None, str|None)]|None): List of (type, state_key) tuples
+ which are used to filter the state fetched. If `state_key` is None,
+ all events are returned of the given type. Presence of type of `None`
+ indicates that types not in the list should not be filtered out.
+ May be None, which matches any key.
Returns:
A deferred dict from event_id -> (type, state_key) -> state_event
@@ -405,9 +450,11 @@ class StateGroupWorkerStore(SQLBaseStore):
Args:
event_id(str): event whose state should be returned
- types(list[(str, str)]|None): List of (type, state_key) tuples
- which are used to filter the state fetched. May be None, which
- matches any key
+ types(list[(str|None, str|None)]|None): List of (type, state_key) tuples
+ which are used to filter the state fetched. If `state_key` is None,
+ all events are returned of the given type. Presence of type of `None`
+ indicates that types not in the list should not be filtered out.
+ May be None, which matches any key.
Returns:
A deferred dict from (type, state_key) -> state_event
@@ -422,9 +469,11 @@ class StateGroupWorkerStore(SQLBaseStore):
Args:
event_id(str): event whose state should be returned
- types(list[(str, str)]|None): List of (type, state_key) tuples
- which are used to filter the state fetched. May be None, which
- matches any key
+ types(list[(str|None, str|None)]|None): List of (type, state_key) tuples
+ which are used to filter the state fetched. If `state_key` is None,
+ all events are returned of the given type. Presence of type of `None`
+ indicates that types not in the list should not be filtered out.
+ May be None, which matches any key.
Returns:
A deferred dict from (type, state_key) -> state_event
@@ -470,20 +519,30 @@ class StateGroupWorkerStore(SQLBaseStore):
missing state.
Args:
- group: The state group to lookup
- types (list): List of 2-tuples of the form (`type`, `state_key`),
- where a `state_key` of `None` matches all state_keys for the
- `type`.
+ group(int): The state group to lookup
+ types(list[str|None, str|None]): List of 2-tuples of the form
+ (`type`, `state_key`), where a `state_key` of `None` matches all
+ state_keys for the `type`. Presence of type of `None` indicates
+ that types not in the list should not be filtered out.
"""
is_all, known_absent, state_dict_ids = self._state_group_cache.get(group)
type_to_key = {}
missing_types = set()
+ include_other_types = False
+
for typ, state_key in types:
key = (typ, state_key)
+
+ if typ is None:
+ include_other_types = True
+ next
+
if state_key is None:
type_to_key[typ] = None
+ # XXX: why do we mark the type as missing from our cache just
+ # because we weren't filtering on a specific value of state_key?
missing_types.add(key)
else:
if type_to_key.get(typ, object()) is not None:
@@ -497,7 +556,7 @@ class StateGroupWorkerStore(SQLBaseStore):
def include(typ, state_key):
valid_state_keys = type_to_key.get(typ, sentinel)
if valid_state_keys is sentinel:
- return False
+ return include_other_types
if valid_state_keys is None:
return True
if state_key in valid_state_keys:
@@ -533,13 +592,14 @@ class StateGroupWorkerStore(SQLBaseStore):
Args:
groups (iterable[int]): list of state groups for which we want
to get the state.
- types (None|iterable[(str, None|str)]):
+ types (None|iterable[(None|str, None|str)]):
indicates the state type/keys required. If None, the whole
state is fetched and returned.
Otherwise, each entry should be a `(type, state_key)` tuple to
include in the response. A `state_key` of None is a wildcard
- meaning that we require all state with that type.
+ meaning that we require all state with that type. A `type` of None
+ indicates that types not in the list should not be filtered out.
Returns:
Deferred[dict[int, dict[(type, state_key), EventBase]]]
|
