2014-08-12 14:10:52 +00:00
|
|
|
# -*- coding: utf-8 -*-
|
2016-01-07 04:26:29 +00:00
|
|
|
# Copyright 2014-2016 OpenMarket Ltd
|
2018-02-23 10:39:19 +00:00
|
|
|
# Copyright 2018 New Vector Ltd
|
2014-08-12 14:10:52 +00: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.
|
|
|
|
|
2014-08-14 17:40:50 +00:00
|
|
|
from twisted.internet import defer
|
2016-07-15 12:19:07 +00:00
|
|
|
|
|
|
|
from synapse.storage.devices import DeviceStore
|
2015-03-09 17:01:19 +00:00
|
|
|
from .appservice import (
|
|
|
|
ApplicationServiceStore, ApplicationServiceTransactionStore
|
|
|
|
)
|
2014-08-12 14:10:52 +00:00
|
|
|
from .directory import DirectoryStore
|
2015-03-20 13:52:56 +00:00
|
|
|
from .events import EventsStore
|
2016-02-15 17:10:40 +00:00
|
|
|
from .presence import PresenceStore, UserPresenceState
|
2014-08-12 14:10:52 +00:00
|
|
|
from .profile import ProfileStore
|
|
|
|
from .registration import RegistrationStore
|
|
|
|
from .room import RoomStore
|
|
|
|
from .roommember import RoomMemberStore
|
|
|
|
from .stream import StreamStore
|
|
|
|
from .transactions import TransactionStore
|
2014-08-28 17:19:47 +00:00
|
|
|
from .keys import KeyStore
|
2014-10-28 16:42:35 +00:00
|
|
|
from .event_federation import EventFederationStore
|
2014-11-19 18:20:59 +00:00
|
|
|
from .pusher import PusherStore
|
2015-01-22 17:38:53 +00:00
|
|
|
from .push_rule import PushRuleStore
|
2014-12-02 19:51:47 +00:00
|
|
|
from .media_repository import MediaRepositoryStore
|
2015-01-22 15:50:17 +00:00
|
|
|
from .rejections import RejectionsStore
|
2016-01-04 14:05:37 +00:00
|
|
|
from .event_push_actions import EventPushActionsStore
|
2016-08-25 16:35:37 +00:00
|
|
|
from .deviceinbox import DeviceInboxStore
|
2017-07-10 14:44:15 +00:00
|
|
|
from .group_server import GroupServerStore
|
2014-10-14 15:59:51 +00:00
|
|
|
from .state import StateStore
|
2014-10-15 16:09:04 +00:00
|
|
|
from .signatures import SignatureStore
|
2015-01-27 17:48:13 +00:00
|
|
|
from .filtering import FilteringStore
|
2015-07-06 17:46:47 +00:00
|
|
|
from .end_to_end_keys import EndToEndKeyStore
|
2014-10-15 16:09:04 +00:00
|
|
|
|
2015-07-07 09:55:31 +00:00
|
|
|
from .receipts import ReceiptsStore
|
2015-10-09 14:48:31 +00:00
|
|
|
from .search import SearchStore
|
2015-10-28 16:06:57 +00:00
|
|
|
from .tags import TagsStore
|
2015-12-01 18:41:32 +00:00
|
|
|
from .account_data import AccountDataStore
|
2016-05-05 12:42:44 +00:00
|
|
|
from .openid import OpenIdStore
|
2016-06-03 13:42:35 +00:00
|
|
|
from .client_ips import ClientIpStore
|
2017-05-31 10:51:01 +00:00
|
|
|
from .user_directory import UserDirectoryStore
|
2015-07-07 09:55:31 +00:00
|
|
|
|
2016-03-08 11:45:50 +00:00
|
|
|
from .util.id_generators import IdGenerator, StreamIdGenerator, ChainedIdGenerator
|
2016-08-15 10:16:45 +00:00
|
|
|
from .engines import PostgresEngine
|
2016-01-26 15:51:06 +00:00
|
|
|
|
2016-02-15 17:10:40 +00:00
|
|
|
from synapse.api.constants import PresenceState
|
2016-01-29 14:37:59 +00:00
|
|
|
from synapse.util.caches.stream_change_cache import StreamChangeCache
|
|
|
|
|
2016-01-26 15:51:06 +00:00
|
|
|
|
2014-08-19 13:20:03 +00:00
|
|
|
import logging
|
2014-08-12 14:10:52 +00:00
|
|
|
|
|
|
|
|
2014-08-19 13:20:03 +00:00
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
2014-09-10 14:42:15 +00:00
|
|
|
|
2014-08-14 16:34:37 +00:00
|
|
|
class DataStore(RoomMemberStore, RoomStore,
|
2015-03-20 13:52:56 +00:00
|
|
|
RegistrationStore, StreamStore, ProfileStore,
|
2014-10-31 14:00:14 +00:00
|
|
|
PresenceStore, TransactionStore,
|
2014-10-28 16:42:35 +00:00
|
|
|
DirectoryStore, KeyStore, StateStore, SignatureStore,
|
2015-02-02 16:05:34 +00:00
|
|
|
ApplicationServiceStore,
|
2014-12-02 19:51:47 +00:00
|
|
|
EventFederationStore,
|
|
|
|
MediaRepositoryStore,
|
2015-01-22 15:50:17 +00:00
|
|
|
RejectionsStore,
|
2015-01-27 17:48:13 +00:00
|
|
|
FilteringStore,
|
2014-12-18 15:15:22 +00:00
|
|
|
PusherStore,
|
2015-03-20 13:52:56 +00:00
|
|
|
PushRuleStore,
|
2015-03-16 10:16:59 +00:00
|
|
|
ApplicationServiceTransactionStore,
|
2015-03-20 13:52:56 +00:00
|
|
|
EventsStore,
|
2015-07-07 09:55:31 +00:00
|
|
|
ReceiptsStore,
|
2015-07-06 17:46:47 +00:00
|
|
|
EndToEndKeyStore,
|
2015-10-09 14:48:31 +00:00
|
|
|
SearchStore,
|
2015-10-28 16:06:57 +00:00
|
|
|
TagsStore,
|
2015-12-01 18:41:32 +00:00
|
|
|
AccountDataStore,
|
2016-05-05 12:42:44 +00:00
|
|
|
EventPushActionsStore,
|
|
|
|
OpenIdStore,
|
2016-06-03 13:42:35 +00:00
|
|
|
ClientIpStore,
|
2016-07-15 12:19:07 +00:00
|
|
|
DeviceStore,
|
2016-08-25 16:35:37 +00:00
|
|
|
DeviceInboxStore,
|
2017-05-31 10:51:01 +00:00
|
|
|
UserDirectoryStore,
|
2017-07-10 14:44:15 +00:00
|
|
|
GroupServerStore,
|
2014-12-02 19:51:47 +00:00
|
|
|
):
|
2014-08-12 14:10:52 +00:00
|
|
|
|
2016-01-28 14:32:05 +00:00
|
|
|
def __init__(self, db_conn, hs):
|
2014-08-18 14:50:41 +00:00
|
|
|
self.hs = hs
|
2016-05-20 16:56:10 +00:00
|
|
|
self._clock = hs.get_clock()
|
2016-01-29 14:41:16 +00:00
|
|
|
self.database_engine = hs.database_engine
|
2014-08-12 14:10:52 +00:00
|
|
|
|
2016-01-26 15:51:06 +00:00
|
|
|
self._stream_id_gen = StreamIdGenerator(
|
2016-04-05 10:13:24 +00:00
|
|
|
db_conn, "events", "stream_ordering",
|
|
|
|
extra_tables=[("local_invites", "stream_id")]
|
2016-01-26 15:51:06 +00:00
|
|
|
)
|
2016-04-01 12:29:05 +00:00
|
|
|
self._backfill_id_gen = StreamIdGenerator(
|
2016-07-15 09:22:30 +00:00
|
|
|
db_conn, "events", "stream_ordering", step=-1,
|
|
|
|
extra_tables=[("ex_outlier_stream", "event_stream_ordering")]
|
2016-04-01 12:29:05 +00:00
|
|
|
)
|
2016-02-15 17:10:40 +00:00
|
|
|
self._presence_id_gen = StreamIdGenerator(
|
|
|
|
db_conn, "presence_stream", "stream_id"
|
|
|
|
)
|
2016-08-25 16:35:37 +00:00
|
|
|
self._device_inbox_id_gen = StreamIdGenerator(
|
2016-09-09 10:48:23 +00:00
|
|
|
db_conn, "device_max_stream_id", "stream_id"
|
2016-08-25 16:35:37 +00:00
|
|
|
)
|
2016-09-14 16:01:02 +00:00
|
|
|
self._public_room_id_gen = StreamIdGenerator(
|
|
|
|
db_conn, "public_room_list_stream", "stream_id"
|
|
|
|
)
|
2017-01-25 14:27:27 +00:00
|
|
|
self._device_list_id_gen = StreamIdGenerator(
|
|
|
|
db_conn, "device_lists_stream", "stream_id",
|
|
|
|
)
|
2016-01-26 15:51:06 +00:00
|
|
|
|
2016-03-01 14:32:56 +00:00
|
|
|
self._transaction_id_gen = IdGenerator(db_conn, "sent_transactions", "id")
|
|
|
|
self._access_tokens_id_gen = IdGenerator(db_conn, "access_tokens", "id")
|
2016-05-04 14:19:12 +00:00
|
|
|
self._event_reports_id_gen = IdGenerator(db_conn, "event_reports", "id")
|
2016-03-01 14:32:56 +00:00
|
|
|
self._push_rule_id_gen = IdGenerator(db_conn, "push_rules", "id")
|
|
|
|
self._push_rules_enable_id_gen = IdGenerator(db_conn, "push_rules_enable", "id")
|
2016-03-01 13:35:37 +00:00
|
|
|
self._push_rules_stream_id_gen = ChainedIdGenerator(
|
|
|
|
self._stream_id_gen, db_conn, "push_rules_stream", "stream_id"
|
|
|
|
)
|
2016-03-15 17:01:43 +00:00
|
|
|
self._pushers_id_gen = StreamIdGenerator(
|
|
|
|
db_conn, "pushers", "id",
|
|
|
|
extra_tables=[("deleted_pushers", "stream_id")],
|
|
|
|
)
|
2017-07-10 13:53:19 +00:00
|
|
|
self._group_updates_id_gen = StreamIdGenerator(
|
|
|
|
db_conn, "local_group_updates", "stream_id",
|
|
|
|
)
|
2016-08-15 10:16:45 +00:00
|
|
|
|
|
|
|
if isinstance(self.database_engine, PostgresEngine):
|
|
|
|
self._cache_id_gen = StreamIdGenerator(
|
2016-08-15 10:45:57 +00:00
|
|
|
db_conn, "cache_invalidation_stream", "stream_id",
|
2016-08-15 10:16:45 +00:00
|
|
|
)
|
|
|
|
else:
|
|
|
|
self._cache_id_gen = None
|
2016-01-26 15:51:06 +00:00
|
|
|
|
2016-06-03 10:05:53 +00:00
|
|
|
self._presence_on_startup = self._get_active_presence(db_conn)
|
2016-02-15 17:10:40 +00:00
|
|
|
|
|
|
|
presence_cache_prefill, min_presence_val = self._get_cache_dict(
|
|
|
|
db_conn, "presence_stream",
|
|
|
|
entity_column="user_id",
|
|
|
|
stream_column="stream_id",
|
2016-04-01 12:29:05 +00:00
|
|
|
max_value=self._presence_id_gen.get_current_token(),
|
2016-02-15 17:10:40 +00:00
|
|
|
)
|
|
|
|
self.presence_stream_cache = StreamChangeCache(
|
|
|
|
"PresenceStreamChangeCache", min_presence_val,
|
|
|
|
prefilled_cache=presence_cache_prefill
|
|
|
|
)
|
|
|
|
|
2016-09-07 14:27:07 +00:00
|
|
|
max_device_inbox_id = self._device_inbox_id_gen.get_current_token()
|
|
|
|
device_inbox_prefill, min_device_inbox_id = self._get_cache_dict(
|
|
|
|
db_conn, "device_inbox",
|
|
|
|
entity_column="user_id",
|
|
|
|
stream_column="stream_id",
|
2017-01-10 14:34:50 +00:00
|
|
|
max_value=max_device_inbox_id,
|
|
|
|
limit=1000,
|
2016-09-07 14:27:07 +00:00
|
|
|
)
|
|
|
|
self._device_inbox_stream_cache = StreamChangeCache(
|
|
|
|
"DeviceInboxStreamChangeCache", min_device_inbox_id,
|
|
|
|
prefilled_cache=device_inbox_prefill,
|
|
|
|
)
|
|
|
|
# The federation outbox and the local device inbox uses the same
|
|
|
|
# stream_id generator.
|
|
|
|
device_outbox_prefill, min_device_outbox_id = self._get_cache_dict(
|
|
|
|
db_conn, "device_federation_outbox",
|
|
|
|
entity_column="destination",
|
|
|
|
stream_column="stream_id",
|
|
|
|
max_value=max_device_inbox_id,
|
2017-01-10 14:34:50 +00:00
|
|
|
limit=1000,
|
2016-09-07 14:27:07 +00:00
|
|
|
)
|
|
|
|
self._device_federation_outbox_stream_cache = StreamChangeCache(
|
2016-09-07 14:58:00 +00:00
|
|
|
"DeviceFederationOutboxStreamChangeCache", min_device_outbox_id,
|
2016-09-07 14:27:07 +00:00
|
|
|
prefilled_cache=device_outbox_prefill,
|
|
|
|
)
|
|
|
|
|
2017-01-25 14:27:27 +00:00
|
|
|
device_list_max = self._device_list_id_gen.get_current_token()
|
|
|
|
self._device_list_stream_cache = StreamChangeCache(
|
|
|
|
"DeviceListStreamChangeCache", device_list_max,
|
|
|
|
)
|
|
|
|
self._device_list_federation_stream_cache = StreamChangeCache(
|
|
|
|
"DeviceListFederationStreamChangeCache", device_list_max,
|
|
|
|
)
|
|
|
|
|
2018-03-01 16:23:48 +00:00
|
|
|
events_max = self._stream_id_gen.get_current_token()
|
2017-05-31 14:46:36 +00:00
|
|
|
curr_state_delta_prefill, min_curr_state_delta_id = self._get_cache_dict(
|
|
|
|
db_conn, "current_state_delta_stream",
|
|
|
|
entity_column="room_id",
|
|
|
|
stream_column="stream_id",
|
|
|
|
max_value=events_max, # As we share the stream id with events token
|
|
|
|
limit=1000,
|
|
|
|
)
|
|
|
|
self._curr_state_delta_stream_cache = StreamChangeCache(
|
|
|
|
"_curr_state_delta_stream_cache", min_curr_state_delta_id,
|
|
|
|
prefilled_cache=curr_state_delta_prefill,
|
|
|
|
)
|
|
|
|
|
2017-07-10 13:53:19 +00:00
|
|
|
_group_updates_prefill, min_group_updates_id = self._get_cache_dict(
|
|
|
|
db_conn, "local_group_updates",
|
|
|
|
entity_column="user_id",
|
|
|
|
stream_column="stream_id",
|
|
|
|
max_value=self._group_updates_id_gen.get_current_token(),
|
|
|
|
limit=1000,
|
|
|
|
)
|
|
|
|
self._group_updates_stream_cache = StreamChangeCache(
|
|
|
|
"_group_updates_stream_cache", min_group_updates_id,
|
|
|
|
prefilled_cache=_group_updates_prefill,
|
|
|
|
)
|
|
|
|
|
2016-09-15 16:34:59 +00:00
|
|
|
self._stream_order_on_start = self.get_room_max_stream_ordering()
|
2016-12-08 13:02:58 +00:00
|
|
|
self._min_stream_order_on_start = self.get_room_min_stream_ordering()
|
2016-09-15 16:34:59 +00:00
|
|
|
|
2017-11-09 18:51:27 +00:00
|
|
|
super(DataStore, self).__init__(db_conn, hs)
|
2016-01-26 15:51:06 +00:00
|
|
|
|
2016-02-15 17:10:40 +00:00
|
|
|
def take_presence_startup_info(self):
|
2016-06-03 10:05:53 +00:00
|
|
|
active_on_startup = self._presence_on_startup
|
|
|
|
self._presence_on_startup = None
|
2016-02-15 17:10:40 +00:00
|
|
|
return active_on_startup
|
|
|
|
|
|
|
|
def _get_active_presence(self, db_conn):
|
|
|
|
"""Fetch non-offline presence from the database so that we can register
|
|
|
|
the appropriate time outs.
|
|
|
|
"""
|
|
|
|
|
|
|
|
sql = (
|
2016-02-18 10:11:43 +00:00
|
|
|
"SELECT user_id, state, last_active_ts, last_federation_update_ts,"
|
|
|
|
" last_user_sync_ts, status_msg, currently_active FROM presence_stream"
|
2016-02-15 17:10:40 +00:00
|
|
|
" WHERE state != ?"
|
|
|
|
)
|
|
|
|
sql = self.database_engine.convert_param_style(sql)
|
|
|
|
|
|
|
|
txn = db_conn.cursor()
|
|
|
|
txn.execute(sql, (PresenceState.OFFLINE,))
|
|
|
|
rows = self.cursor_to_dict(txn)
|
2016-02-18 16:39:28 +00:00
|
|
|
txn.close()
|
2016-02-15 17:10:40 +00:00
|
|
|
|
|
|
|
for row in rows:
|
|
|
|
row["currently_active"] = bool(row["currently_active"])
|
|
|
|
|
|
|
|
return [UserPresenceState(**row) for row in rows]
|
|
|
|
|
2015-09-22 11:57:40 +00:00
|
|
|
@defer.inlineCallbacks
|
|
|
|
def count_daily_users(self):
|
2015-09-22 12:47:40 +00:00
|
|
|
"""
|
|
|
|
Counts the number of users who used this homeserver in the last 24 hours.
|
|
|
|
"""
|
2015-09-22 11:57:40 +00:00
|
|
|
def _count_users(txn):
|
2018-03-28 10:49:57 +00:00
|
|
|
yesterday = int(self._clock.time_msec()) - (1000 * 60 * 60 * 24)
|
2017-06-14 18:37:17 +00:00
|
|
|
|
|
|
|
sql = """
|
|
|
|
SELECT COALESCE(count(*), 0) FROM (
|
|
|
|
SELECT user_id FROM user_ips
|
|
|
|
WHERE last_seen > ?
|
|
|
|
GROUP BY user_id
|
|
|
|
) u
|
|
|
|
"""
|
|
|
|
|
2018-03-28 10:49:57 +00:00
|
|
|
txn.execute(sql, (yesterday,))
|
2017-06-14 18:37:17 +00:00
|
|
|
count, = txn.fetchone()
|
|
|
|
return count
|
2015-09-22 11:57:40 +00:00
|
|
|
|
|
|
|
ret = yield self.runInteraction("count_users", _count_users)
|
|
|
|
defer.returnValue(ret)
|
|
|
|
|
2018-03-28 09:39:13 +00:00
|
|
|
@defer.inlineCallbacks
|
|
|
|
def count_r30_users(self):
|
|
|
|
"""
|
|
|
|
Counts the number of 30 day retained users, defined as:-
|
|
|
|
* Users who have created their accounts more than 30 days
|
|
|
|
* Where last seen at most 30 days ago
|
|
|
|
* Where account creation and last_seen are > 30 days
|
|
|
|
"""
|
|
|
|
def _count_r30_users(txn):
|
|
|
|
thirty_days_in_secs = 86400 * 30
|
|
|
|
now = int(self._clock.time_msec())
|
|
|
|
thirty_days_ago_in_secs = now - thirty_days_in_secs
|
|
|
|
|
|
|
|
sql = """
|
|
|
|
SELECT COALESCE(count(*), 0) FROM (
|
|
|
|
SELECT users.name, users.creation_ts * 1000, MAX(user_ips.last_seen)
|
|
|
|
FROM users, user_ips
|
|
|
|
WHERE users.name = user_ips.user_id
|
|
|
|
AND appservice_id is NULL
|
|
|
|
AND users.creation_ts < ?
|
|
|
|
AND user_ips.last_seen/1000 > ?
|
|
|
|
AND (user_ips.last_seen/1000) - users.creation_ts > ?
|
|
|
|
GROUP BY users.name, users.creation_ts
|
|
|
|
) u
|
|
|
|
"""
|
|
|
|
|
|
|
|
txn.execute(sql, (thirty_days_ago_in_secs,
|
|
|
|
thirty_days_ago_in_secs,
|
|
|
|
thirty_days_in_secs))
|
|
|
|
|
|
|
|
count, = txn.fetchone()
|
|
|
|
return count
|
|
|
|
|
|
|
|
ret = yield self.runInteraction("count_r30_users", _count_r30_users)
|
|
|
|
defer.returnValue(ret)
|
|
|
|
|
2017-02-02 13:02:26 +00:00
|
|
|
def get_users(self):
|
|
|
|
"""Function to reterive a list of users in users table.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
Returns:
|
|
|
|
defer.Deferred: resolves to list[dict[str, Any]]
|
|
|
|
"""
|
|
|
|
return self._simple_select_list(
|
|
|
|
table="users",
|
|
|
|
keyvalues={},
|
|
|
|
retcols=[
|
|
|
|
"name",
|
|
|
|
"password_hash",
|
|
|
|
"is_guest",
|
|
|
|
"admin"
|
|
|
|
],
|
|
|
|
desc="get_users",
|
|
|
|
)
|
|
|
|
|
|
|
|
def get_users_paginate(self, order, start, limit):
|
|
|
|
"""Function to reterive a paginated list of users from
|
|
|
|
users list. This will return a json object, which contains
|
|
|
|
list of users and the total number of users in users table.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
order (str): column name to order the select by this column
|
|
|
|
start (int): start number to begin the query from
|
|
|
|
limit (int): number of rows to reterive
|
|
|
|
Returns:
|
|
|
|
defer.Deferred: resolves to json object {list[dict[str, Any]], count}
|
|
|
|
"""
|
|
|
|
is_guest = 0
|
|
|
|
i_start = (int)(start)
|
|
|
|
i_limit = (int)(limit)
|
|
|
|
return self.get_user_list_paginate(
|
|
|
|
table="users",
|
|
|
|
keyvalues={
|
|
|
|
"is_guest": is_guest
|
|
|
|
},
|
|
|
|
pagevalues=[
|
|
|
|
order,
|
|
|
|
i_limit,
|
|
|
|
i_start
|
|
|
|
],
|
|
|
|
retcols=[
|
|
|
|
"name",
|
|
|
|
"password_hash",
|
|
|
|
"is_guest",
|
|
|
|
"admin"
|
|
|
|
],
|
|
|
|
desc="get_users_paginate",
|
|
|
|
)
|
|
|
|
|
|
|
|
def search_users(self, term):
|
|
|
|
"""Function to search users list for one or more users with
|
|
|
|
the matched term.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
term (str): search term
|
|
|
|
col (str): column to query term should be matched to
|
|
|
|
Returns:
|
|
|
|
defer.Deferred: resolves to list[dict[str, Any]]
|
|
|
|
"""
|
|
|
|
return self._simple_search_list(
|
|
|
|
table="users",
|
|
|
|
term=term,
|
|
|
|
col="name",
|
|
|
|
retcols=[
|
|
|
|
"name",
|
|
|
|
"password_hash",
|
|
|
|
"is_guest",
|
|
|
|
"admin"
|
|
|
|
],
|
|
|
|
desc="search_users",
|
|
|
|
)
|
|
|
|
|
2014-08-22 16:00:10 +00:00
|
|
|
|
2015-04-28 12:39:42 +00:00
|
|
|
def are_all_users_on_domain(txn, database_engine, domain):
|
|
|
|
sql = database_engine.convert_param_style(
|
|
|
|
"SELECT COUNT(*) FROM users WHERE name NOT LIKE ?"
|
|
|
|
)
|
2015-04-27 10:46:00 +00:00
|
|
|
pat = "%:" + domain
|
2015-04-28 12:39:42 +00:00
|
|
|
txn.execute(sql, (pat,))
|
|
|
|
num_not_matching = txn.fetchall()[0][0]
|
2015-04-27 10:46:00 +00:00
|
|
|
if num_not_matching == 0:
|
|
|
|
return True
|
2015-04-27 10:49:18 +00:00
|
|
|
return False
|