diff --git a/keyserver/src/creators/message-creator.js b/keyserver/src/creators/message-creator.js
index 4b56daa7b..b904876b7 100644
--- a/keyserver/src/creators/message-creator.js
+++ b/keyserver/src/creators/message-creator.js
@@ -1,607 +1,602 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { permissionLookup } from 'lib/permissions/thread-permissions';
 import {
   rawMessageInfoFromMessageData,
   messageTypeGeneratesNotifs,
   shimUnsupportedRawMessageInfos,
   stripLocalIDs,
 } from 'lib/shared/message-utils';
 import { messageSpecs } from 'lib/shared/messages/message-specs';
 import {
   messageTypes,
   messageDataLocalID,
   type MessageData,
   type RawMessageInfo,
 } from 'lib/types/message-types';
 import { redisMessageTypes } from 'lib/types/redis-types';
 import { threadPermissions } from 'lib/types/thread-types';
 import { updateTypes } from 'lib/types/update-types';
 
 import {
   dbQuery,
   SQL,
   appendSQLArray,
   mergeOrConditions,
 } from '../database/database';
-import { getDBType } from '../database/db-config';
 import { fetchMessageInfoForLocalID } from '../fetchers/message-fetchers';
 import { fetchOtherSessionsForViewer } from '../fetchers/session-fetchers';
 import { fetchServerThreadInfos } from '../fetchers/thread-fetchers';
 import { sendPushNotifs } from '../push/send';
 import { handleAsyncPromise } from '../responders/handlers';
 import type { Viewer } from '../session/viewer';
 import { earliestFocusedTimeConsideredExpired } from '../shared/focused-times';
 import { publisher } from '../socket/redis';
 import { creationString } from '../utils/idempotent';
 import createIDs from './id-creator';
 import type { UpdatesForCurrentSession } from './update-creator';
 import { createUpdates } from './update-creator';
 
 type UserThreadInfo = {
   +devices: Map<
     string,
     {
       +deviceType: string,
       +deviceToken: string,
       +codeVersion: ?string,
     },
   >,
   +threadIDs: Set<string>,
   +notFocusedThreadIDs: Set<string>,
   +subthreadsCanNotify: Set<string>,
   +subthreadsCanSetToUnread: Set<string>,
 };
 
 type LatestMessagesPerUser = Map<
   string,
   $ReadOnlyMap<
     string,
     {
       +latestMessage: string,
       +latestReadMessage?: string,
     },
   >,
 >;
 
 type LatestMessages = $ReadOnlyArray<{
   +userID: string,
   +threadID: string,
   +latestMessage: string,
   +latestReadMessage: ?string,
 }>;
 
 // Does not do permission checks! (checkThreadPermission)
 async function createMessages(
   viewer: Viewer,
   messageDatas: $ReadOnlyArray<MessageData>,
   updatesForCurrentSession?: UpdatesForCurrentSession = 'return',
 ): Promise<RawMessageInfo[]> {
   if (messageDatas.length === 0) {
     return [];
   }
 
   const messageInfos: RawMessageInfo[] = [];
   const newMessageDatas: MessageData[] = [];
   const existingMessages = await Promise.all(
     messageDatas.map(messageData =>
       fetchMessageInfoForLocalID(viewer, messageDataLocalID(messageData)),
     ),
   );
   for (let i = 0; i < existingMessages.length; i++) {
     const existingMessage = existingMessages[i];
     if (existingMessage) {
       messageInfos.push(existingMessage);
     } else {
       newMessageDatas.push(messageDatas[i]);
     }
   }
   if (newMessageDatas.length === 0) {
     return shimUnsupportedRawMessageInfos(messageInfos, viewer.platformDetails);
   }
 
   const ids = await createIDs('messages', newMessageDatas.length);
 
   const subthreadPermissionsToCheck: Set<string> = new Set();
   const threadsToMessageIndices: Map<string, number[]> = new Map();
   const messageInsertRows = [];
   for (let i = 0; i < newMessageDatas.length; i++) {
     const messageData = newMessageDatas[i];
     const threadID = messageData.threadID;
     const creatorID = messageData.creatorID;
 
     if (messageData.type === messageTypes.CREATE_SUB_THREAD) {
       subthreadPermissionsToCheck.add(messageData.childThreadID);
     }
 
     let messageIndices = threadsToMessageIndices.get(threadID);
     if (!messageIndices) {
       messageIndices = [];
       threadsToMessageIndices.set(threadID, messageIndices);
     }
     messageIndices.push(i);
 
     const content = messageSpecs[messageData.type].messageContentForServerDB?.(
       messageData,
     );
 
     const creation =
       messageData.localID && viewer.hasSessionInfo
         ? creationString(viewer, messageData.localID)
         : null;
 
     messageInsertRows.push([
       ids[i],
       threadID,
       creatorID,
       messageData.type,
       content,
       messageData.time,
       creation,
     ]);
     messageInfos.push(rawMessageInfoFromMessageData(messageData, ids[i]));
   }
 
   if (viewer.isScriptViewer) {
     await postMessageSend(
       viewer,
       threadsToMessageIndices,
       subthreadPermissionsToCheck,
       stripLocalIDs(messageInfos),
       updatesForCurrentSession,
     );
   } else {
     // We aren't awaiting because this function calls external services and we
     // don't want to delay the response
     handleAsyncPromise(
       postMessageSend(
         viewer,
         threadsToMessageIndices,
         subthreadPermissionsToCheck,
         stripLocalIDs(messageInfos),
         updatesForCurrentSession,
       ),
     );
   }
 
   const messageInsertQuery = SQL`
     INSERT INTO messages(id, thread, user, type, content, time, creation)
     VALUES ${messageInsertRows}
   `;
   await Promise.all([
     dbQuery(messageInsertQuery),
     updateRepliesCount(threadsToMessageIndices, newMessageDatas),
   ]);
 
   if (updatesForCurrentSession !== 'return') {
     return [];
   }
 
   return shimUnsupportedRawMessageInfos(messageInfos, viewer.platformDetails);
 }
 
 async function updateRepliesCount(
   threadsToMessageIndices: Map<string, number[]>,
   newMessageDatas: MessageData[],
 ) {
   const updatedThreads = [];
 
   const updateThreads = SQL`
     UPDATE threads
     SET replies_count = replies_count + (CASE `;
 
   const membershipConditions = [];
   for (const [threadID, messages] of threadsToMessageIndices.entries()) {
     const newRepliesIncrease = messages
       .map(i => newMessageDatas[i].type)
       .filter(type => messageSpecs[type].includedInRepliesCount).length;
     if (newRepliesIncrease === 0) {
       continue;
     }
 
     updateThreads.append(SQL`
       WHEN id = ${threadID} THEN ${newRepliesIncrease}
     `);
     updatedThreads.push(threadID);
 
     const senders = messages.map(i => newMessageDatas[i].creatorID);
     membershipConditions.push(
       SQL`thread = ${threadID} AND user IN (${senders})`,
     );
   }
   updateThreads.append(SQL`
       ELSE 0
       END)
     WHERE id IN (${updatedThreads})
       AND source_message IS NOT NULL
   `);
 
   const updateMemberships = SQL`
     UPDATE memberships
     SET sender = 1
     WHERE sender = 0 
       AND (
   `;
   updateMemberships.append(mergeOrConditions(membershipConditions));
   updateMemberships.append(SQL`
       )
   `);
 
   if (updatedThreads.length > 0) {
     const [{ threadInfos: serverThreadInfos }] = await Promise.all([
       fetchServerThreadInfos(SQL`t.id IN (${updatedThreads})`),
       dbQuery(updateThreads),
       dbQuery(updateMemberships),
     ]);
 
     const time = Date.now();
     const updates = [];
     for (const threadID in serverThreadInfos) {
       for (const member of serverThreadInfos[threadID].members) {
         updates.push({
           userID: member.id,
           time,
           threadID,
           type: updateTypes.UPDATE_THREAD,
         });
       }
     }
     await createUpdates(updates);
   }
 }
 
 // Handles:
 // (1) Sending push notifs
 // (2) Setting threads to unread and generating corresponding UpdateInfos
 // (3) Publishing to Redis so that active sockets pass on new messages
 async function postMessageSend(
   viewer: Viewer,
   threadsToMessageIndices: Map<string, number[]>,
   subthreadPermissionsToCheck: Set<string>,
   messageInfos: RawMessageInfo[],
   updatesForCurrentSession: UpdatesForCurrentSession,
 ) {
   let joinIndex = 0;
   let subthreadSelects = '';
   const subthreadJoins = [];
   for (const subthread of subthreadPermissionsToCheck) {
     const index = joinIndex++;
     subthreadSelects += `
       ,
       stm${index}.permissions AS subthread${subthread}_permissions,
       stm${index}.role AS subthread${subthread}_role
     `;
     const join = SQL`LEFT JOIN memberships `;
     join.append(`stm${index} ON stm${index}.`);
     join.append(SQL`thread = ${subthread} AND `);
     join.append(`stm${index}.user = m.user`);
     subthreadJoins.push(join);
   }
 
   const time = earliestFocusedTimeConsideredExpired();
   const visibleExtractString = `$.${threadPermissions.VISIBLE}.value`;
   const query = SQL`
     SELECT m.user, m.thread, c.platform, c.device_token, c.versions,
       f.user AS focused_user
   `;
   query.append(subthreadSelects);
   query.append(SQL`
     FROM memberships m
     LEFT JOIN cookies c ON c.user = m.user AND c.device_token IS NOT NULL
     LEFT JOIN focused f ON f.user = m.user AND f.thread = m.thread
       AND f.time > ${time}
   `);
   appendSQLArray(query, subthreadJoins, SQL` `);
   query.append(SQL`
     WHERE (m.role > 0 OR f.user IS NOT NULL) AND
       JSON_EXTRACT(m.permissions, ${visibleExtractString}) IS TRUE AND
       m.thread IN (${[...threadsToMessageIndices.keys()]})
   `);
 
   const perUserInfo = new Map<string, UserThreadInfo>();
-  const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+  const [result] = await dbQuery(query);
   for (const row of result) {
     const userID = row.user.toString();
     const threadID = row.thread.toString();
     const deviceToken = row.device_token;
     const focusedUser = !!row.focused_user;
     const { platform } = row;
-    const versions =
-      dbType === 'mysql5.7' ? row.versions : JSON.parse(row.versions);
+    const versions = JSON.parse(row.versions);
     let thisUserInfo = perUserInfo.get(userID);
     if (!thisUserInfo) {
       thisUserInfo = {
         devices: new Map(),
         threadIDs: new Set(),
         notFocusedThreadIDs: new Set(),
         subthreadsCanNotify: new Set(),
         subthreadsCanSetToUnread: new Set(),
       };
       perUserInfo.set(userID, thisUserInfo);
       // Subthread info will be the same for each subthread, so we only parse
       // it once
       for (const subthread of subthreadPermissionsToCheck) {
         const isSubthreadMember = row[`subthread${subthread}_role`] > 0;
         const rawSubthreadPermissions =
           row[`subthread${subthread}_permissions`];
-        const subthreadPermissions =
-          dbType === 'mysql5.7'
-            ? rawSubthreadPermissions
-            : JSON.parse(rawSubthreadPermissions);
+        const subthreadPermissions = JSON.parse(rawSubthreadPermissions);
         const canSeeSubthread = permissionLookup(
           subthreadPermissions,
           threadPermissions.KNOW_OF,
         );
         if (!canSeeSubthread) {
           continue;
         }
         thisUserInfo.subthreadsCanSetToUnread.add(subthread);
         // Only include the notification from the superthread if there is no
         // notification from the subthread
         if (
           !isSubthreadMember ||
           !permissionLookup(subthreadPermissions, threadPermissions.VISIBLE)
         ) {
           thisUserInfo.subthreadsCanNotify.add(subthread);
         }
       }
     }
     if (deviceToken) {
       thisUserInfo.devices.set(deviceToken, {
         deviceType: platform,
         deviceToken,
         codeVersion: versions ? versions.codeVersion : null,
       });
     }
     thisUserInfo.threadIDs.add(threadID);
     if (!focusedUser) {
       thisUserInfo.notFocusedThreadIDs.add(threadID);
     }
   }
 
   const pushInfo = {};
   const messageInfosPerUser = {};
   const latestMessagesPerUser: LatestMessagesPerUser = new Map();
   for (const pair of perUserInfo) {
     const [userID, preUserPushInfo] = pair;
     const { subthreadsCanNotify } = preUserPushInfo;
     const userPushInfo = {
       devices: [...preUserPushInfo.devices.values()],
       messageInfos: [],
     };
 
     for (const threadID of preUserPushInfo.notFocusedThreadIDs) {
       const messageIndices = threadsToMessageIndices.get(threadID);
       invariant(messageIndices, `indices should exist for thread ${threadID}`);
       for (const messageIndex of messageIndices) {
         const messageInfo = messageInfos[messageIndex];
         if (
           (messageInfo.type !== messageTypes.CREATE_SUB_THREAD ||
             subthreadsCanNotify.has(messageInfo.childThreadID)) &&
           messageTypeGeneratesNotifs(messageInfo.type) &&
           messageInfo.creatorID !== userID
         ) {
           userPushInfo.messageInfos.push(messageInfo);
         }
       }
     }
     if (
       userPushInfo.devices.length > 0 &&
       userPushInfo.messageInfos.length > 0
     ) {
       pushInfo[userID] = userPushInfo;
     }
     const userMessageInfos = [];
     for (const threadID of preUserPushInfo.threadIDs) {
       const messageIndices = threadsToMessageIndices.get(threadID);
       invariant(messageIndices, `indices should exist for thread ${threadID}`);
       for (const messageIndex of messageIndices) {
         const messageInfo = messageInfos[messageIndex];
         userMessageInfos.push(messageInfo);
       }
     }
     if (userMessageInfos.length > 0) {
       messageInfosPerUser[userID] = userMessageInfos;
     }
 
     latestMessagesPerUser.set(
       userID,
       determineLatestMessagesPerThread(
         preUserPushInfo,
         userID,
         threadsToMessageIndices,
         messageInfos,
       ),
     );
   }
 
   const latestMessages = flattenLatestMessagesPerUser(latestMessagesPerUser);
 
   await Promise.all([
     createReadStatusUpdates(latestMessages),
     redisPublish(viewer, messageInfosPerUser, updatesForCurrentSession),
     updateLatestMessages(latestMessages),
   ]);
 
   await sendPushNotifs(pushInfo);
 }
 
 async function redisPublish(
   viewer: Viewer,
   messageInfosPerUser: { [userID: string]: $ReadOnlyArray<RawMessageInfo> },
   updatesForCurrentSession: UpdatesForCurrentSession,
 ) {
   const avoidBroadcastingToCurrentSession =
     viewer.hasSessionInfo && updatesForCurrentSession !== 'broadcast';
   for (const userID in messageInfosPerUser) {
     if (userID === viewer.userID && avoidBroadcastingToCurrentSession) {
       continue;
     }
     const messageInfos = messageInfosPerUser[userID];
     publisher.sendMessage(
       { userID },
       {
         type: redisMessageTypes.NEW_MESSAGES,
         messages: messageInfos,
       },
     );
   }
   const viewerMessageInfos = messageInfosPerUser[viewer.userID];
   if (!viewerMessageInfos || !avoidBroadcastingToCurrentSession) {
     return;
   }
   const sessionIDs = await fetchOtherSessionsForViewer(viewer);
   for (const sessionID of sessionIDs) {
     publisher.sendMessage(
       { userID: viewer.userID, sessionID },
       {
         type: redisMessageTypes.NEW_MESSAGES,
         messages: viewerMessageInfos,
       },
     );
   }
 }
 
 function determineLatestMessagesPerThread(
   preUserPushInfo: UserThreadInfo,
   userID: string,
   threadsToMessageIndices: $ReadOnlyMap<string, $ReadOnlyArray<number>>,
   messageInfos: $ReadOnlyArray<RawMessageInfo>,
 ) {
   const {
     threadIDs,
     notFocusedThreadIDs,
     subthreadsCanSetToUnread,
   } = preUserPushInfo;
   const latestMessagesPerThread = new Map();
   for (const threadID of threadIDs) {
     const messageIndices = threadsToMessageIndices.get(threadID);
     invariant(messageIndices, `indices should exist for thread ${threadID}`);
     for (const messageIndex of messageIndices) {
       const messageInfo = messageInfos[messageIndex];
       if (
         messageInfo.type === messageTypes.CREATE_SUB_THREAD &&
         !subthreadsCanSetToUnread.has(messageInfo.childThreadID)
       ) {
         continue;
       }
 
       const messageID = messageInfo.id;
       invariant(
         messageID,
         'message ID should exist in determineLatestMessagesPerThread',
       );
 
       if (
         notFocusedThreadIDs.has(threadID) &&
         messageInfo.creatorID !== userID
       ) {
         latestMessagesPerThread.set(threadID, {
           latestMessage: messageID,
         });
       } else {
         latestMessagesPerThread.set(threadID, {
           latestMessage: messageID,
           latestReadMessage: messageID,
         });
       }
     }
   }
   return latestMessagesPerThread;
 }
 
 function flattenLatestMessagesPerUser(
   latestMessagesPerUser: LatestMessagesPerUser,
 ): LatestMessages {
   const result = [];
   for (const [userID, latestMessagesPerThread] of latestMessagesPerUser) {
     for (const [threadID, latestMessages] of latestMessagesPerThread) {
       result.push({
         userID,
         threadID,
         latestMessage: latestMessages.latestMessage,
         latestReadMessage: latestMessages.latestReadMessage,
       });
     }
   }
   return result;
 }
 
 async function createReadStatusUpdates(latestMessages: LatestMessages) {
   const now = Date.now();
   const readStatusUpdates = latestMessages
     .filter(message => !message.latestReadMessage)
     .map(({ userID, threadID }) => ({
       type: updateTypes.UPDATE_THREAD_READ_STATUS,
       userID,
       time: now,
       threadID,
       unread: true,
     }));
 
   if (readStatusUpdates.length === 0) {
     return;
   }
 
   return await createUpdates(readStatusUpdates);
 }
 
 function updateLatestMessages(latestMessages: LatestMessages) {
   if (latestMessages.length === 0) {
     return;
   }
 
   const query = SQL`
     UPDATE memberships
     SET 
   `;
 
   const lastMessageExpression = SQL`
     last_message = GREATEST(last_message, CASE 
   `;
   const lastReadMessageExpression = SQL`
     , last_read_message = GREATEST(last_read_message, CASE 
   `;
   let shouldUpdateLastReadMessage = false;
   for (const {
     userID,
     threadID,
     latestMessage,
     latestReadMessage,
   } of latestMessages) {
     lastMessageExpression.append(SQL`
       WHEN user = ${userID} AND thread = ${threadID} THEN ${latestMessage}
     `);
     if (latestReadMessage) {
       shouldUpdateLastReadMessage = true;
       lastReadMessageExpression.append(SQL`
         WHEN user = ${userID} AND thread = ${threadID} THEN ${latestReadMessage}
       `);
     }
   }
   lastMessageExpression.append(SQL`
     ELSE last_message
     END)
   `);
   lastReadMessageExpression.append(SQL`
     ELSE last_read_message
     END)
   `);
 
   const conditions = latestMessages.map(
     ({ userID, threadID }) => SQL`(user = ${userID} AND thread = ${threadID})`,
   );
 
   query.append(lastMessageExpression);
   if (shouldUpdateLastReadMessage) {
     query.append(lastReadMessageExpression);
   }
   query.append(SQL`WHERE `);
   query.append(mergeOrConditions(conditions));
 
   return dbQuery(query);
 }
 
 export default createMessages;
diff --git a/keyserver/src/creators/session-creator.js b/keyserver/src/creators/session-creator.js
index 2166153b4..99c02a99b 100644
--- a/keyserver/src/creators/session-creator.js
+++ b/keyserver/src/creators/session-creator.js
@@ -1,53 +1,40 @@
 // @flow
 
 import type { CalendarQuery } from 'lib/types/entry-types';
 
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 import type { Viewer } from '../session/viewer';
 
 async function createSession(
   viewer: Viewer,
   calendarQuery: CalendarQuery,
   initialLastUpdate: number,
 ): Promise<void> {
   const time = Date.now();
   const row = [
     viewer.session,
     viewer.userID,
     viewer.cookieID,
     JSON.stringify(calendarQuery),
     time,
     initialLastUpdate,
     time,
   ];
   const query = SQL`
     INSERT INTO sessions (id, user, cookie, query,
       creation_time, last_update, last_validated)
     VALUES ${[row]}
-  `;
-  const dbType = await getDBType();
-  if (dbType === 'mysql5.7') {
-    query.append(SQL`
-    ON DUPLICATE KEY UPDATE
-      query = VALUES(query),
-      last_update = VALUES(last_update),
-      last_validated = VALUES(last_validated)
-    `);
-  } else {
-    query.append(SQL`
     ON DUPLICATE KEY UPDATE
       query = VALUE(query),
       last_update = VALUE(last_update),
       last_validated = VALUE(last_validated)
-    `);
-  }
+  `;
   await dbQuery(query);
   viewer.setSessionInfo({
     lastValidated: time,
     lastUpdate: initialLastUpdate,
     calendarQuery,
   });
 }
 
 export { createSession };
diff --git a/keyserver/src/fetchers/entry-fetchers.js b/keyserver/src/fetchers/entry-fetchers.js
index 09454ab91..26c93916f 100644
--- a/keyserver/src/fetchers/entry-fetchers.js
+++ b/keyserver/src/fetchers/entry-fetchers.js
@@ -1,330 +1,328 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { permissionLookup } from 'lib/permissions/thread-permissions';
 import {
   filteredThreadIDs,
   filterExists,
   nonExcludeDeletedCalendarFilters,
 } from 'lib/selectors/calendar-filter-selectors';
 import { rawEntryInfoWithinCalendarQuery } from 'lib/shared/entry-utils';
 import type {
   CalendarQuery,
   FetchEntryInfosBase,
   DeltaEntryInfosResponse,
   RawEntryInfo,
 } from 'lib/types/entry-types';
 import { calendarThreadFilterTypes } from 'lib/types/filter-types';
 import type { HistoryRevisionInfo } from 'lib/types/history-types';
 import {
   threadPermissions,
   type ThreadPermission,
 } from 'lib/types/thread-types';
 import { ServerError } from 'lib/utils/errors';
 
 import {
   dbQuery,
   SQL,
   mergeAndConditions,
   mergeOrConditions,
 } from '../database/database';
-import { getDBType } from '../database/db-config';
 import type { SQLStatementType } from '../database/types';
 import type { Viewer } from '../session/viewer';
 import { creationString } from '../utils/idempotent';
 import { checkIfThreadIsBlocked } from './thread-permission-fetchers';
 
 async function fetchEntryInfo(
   viewer: Viewer,
   entryID: string,
 ): Promise<?RawEntryInfo> {
   const results = await fetchEntryInfosByID(viewer, [entryID]);
   if (results.length === 0) {
     return null;
   }
   return results[0];
 }
 
 function rawEntryInfoFromRow(row: Object): RawEntryInfo {
   return {
     id: row.id.toString(),
     threadID: row.threadID.toString(),
     text: row.text,
     year: row.year,
     month: row.month,
     day: row.day,
     creationTime: row.creationTime,
     creatorID: row.creatorID.toString(),
     deleted: !!row.deleted,
   };
 }
 
 const visPermissionExtractString = `$.${threadPermissions.VISIBLE}.value`;
 async function fetchEntryInfosByID(
   viewer: Viewer,
   entryIDs: $ReadOnlyArray<string>,
 ): Promise<RawEntryInfo[]> {
   if (entryIDs.length === 0) {
     return [];
   }
   const viewerID = viewer.id;
   const query = SQL`
     SELECT DAY(d.date) AS day, MONTH(d.date) AS month, YEAR(d.date) AS year,
       e.id, e.text, e.creation_time AS creationTime, d.thread AS threadID,
       e.deleted, e.creator AS creatorID
     FROM entries e
     LEFT JOIN days d ON d.id = e.day
     LEFT JOIN memberships m ON m.thread = d.thread AND m.user = ${viewerID}
     WHERE e.id IN (${entryIDs}) AND
       JSON_EXTRACT(m.permissions, ${visPermissionExtractString}) IS TRUE
   `;
   const [result] = await dbQuery(query);
   return result.map(rawEntryInfoFromRow);
 }
 
 function sqlConditionForCalendarQuery(
   calendarQuery: CalendarQuery,
 ): ?SQLStatementType {
   const { filters, startDate, endDate } = calendarQuery;
   const conditions = [];
 
   conditions.push(SQL`d.date BETWEEN ${startDate} AND ${endDate}`);
 
   const filterToThreadIDs = filteredThreadIDs(filters);
   if (filterToThreadIDs && filterToThreadIDs.size > 0) {
     conditions.push(SQL`d.thread IN (${[...filterToThreadIDs]})`);
   } else if (filterToThreadIDs) {
     // Filter to empty set means the result is empty
     return null;
   } else {
     conditions.push(SQL`m.role > 0`);
   }
 
   if (filterExists(filters, calendarThreadFilterTypes.NOT_DELETED)) {
     conditions.push(SQL`e.deleted = 0`);
   }
 
   return mergeAndConditions(conditions);
 }
 
 async function fetchEntryInfos(
   viewer: Viewer,
   calendarQueries: $ReadOnlyArray<CalendarQuery>,
 ): Promise<FetchEntryInfosBase> {
   const queryConditions = calendarQueries
     .map(sqlConditionForCalendarQuery)
     .filter(Boolean);
   if (queryConditions.length === 0) {
     return { rawEntryInfos: [] };
   }
   const queryCondition = mergeOrConditions(queryConditions);
 
   const viewerID = viewer.id;
   const query = SQL`
     SELECT DAY(d.date) AS day, MONTH(d.date) AS month, YEAR(d.date) AS year,
       e.id, e.text, e.creation_time AS creationTime, d.thread AS threadID,
       e.deleted, e.creator AS creatorID
     FROM entries e
     LEFT JOIN days d ON d.id = e.day
     LEFT JOIN memberships m ON m.thread = d.thread AND m.user = ${viewerID}
     WHERE JSON_EXTRACT(m.permissions, ${visPermissionExtractString}) IS TRUE AND
   `;
   query.append(queryCondition);
   query.append(SQL`ORDER BY e.creation_time DESC`);
   const [result] = await dbQuery(query);
 
   const rawEntryInfos = [];
   for (const row of result) {
     rawEntryInfos.push(rawEntryInfoFromRow(row));
   }
   return { rawEntryInfos };
 }
 
 async function checkThreadPermissionForEntry(
   viewer: Viewer,
   entryID: string,
   permission: ThreadPermission,
 ): Promise<boolean> {
   const viewerID = viewer.id;
   const query = SQL`
     SELECT m.permissions, t.id
     FROM entries e
     LEFT JOIN days d ON d.id = e.day
     LEFT JOIN threads t ON t.id = d.thread
     LEFT JOIN memberships m ON m.thread = t.id AND m.user = ${viewerID}
     WHERE e.id = ${entryID}
   `;
-  const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+  const [result] = await dbQuery(query);
 
   if (result.length === 0) {
     return false;
   }
   const row = result[0];
   if (row.id === null) {
     return false;
   }
   const threadIsBlocked = await checkIfThreadIsBlocked(
     viewer,
     row.id.toString(),
     permission,
   );
   if (threadIsBlocked) {
     return false;
   }
 
-  const permissions =
-    dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions);
+  const permissions = JSON.parse(row.permissions);
   return permissionLookup(permissions, permission);
 }
 
 async function fetchEntryRevisionInfo(
   viewer: Viewer,
   entryID: string,
 ): Promise<$ReadOnlyArray<HistoryRevisionInfo>> {
   const hasPermission = await checkThreadPermissionForEntry(
     viewer,
     entryID,
     threadPermissions.VISIBLE,
   );
   if (!hasPermission) {
     throw new ServerError('invalid_credentials');
   }
 
   const query = SQL`
     SELECT r.id, u.username AS author, r.text, r.last_update AS lastUpdate,
       r.deleted, d.thread AS threadID, r.entry AS entryID
     FROM revisions r
     LEFT JOIN users u ON u.id = r.author
     LEFT JOIN entries e ON e.id = r.entry
     LEFT JOIN days d ON d.id = e.day
     WHERE r.entry = ${entryID}
     ORDER BY r.last_update DESC
   `;
   const [result] = await dbQuery(query);
 
   const revisions = [];
   for (const row of result) {
     revisions.push({
       id: row.id.toString(),
       author: row.author,
       text: row.text,
       lastUpdate: row.lastUpdate,
       deleted: !!row.deleted,
       threadID: row.threadID.toString(),
       entryID: row.entryID.toString(),
     });
   }
   return revisions;
 }
 
 // calendarQueries are the "difference" queries we get from subtracting the old
 // CalendarQuery from the new one. See calendarQueryDifference.
 // oldCalendarQuery is the old CalendarQuery. We make sure none of the returned
 // RawEntryInfos match the old CalendarQuery, so that only the difference is
 // returned.
 async function fetchEntriesForSession(
   viewer: Viewer,
   calendarQueries: $ReadOnlyArray<CalendarQuery>,
   oldCalendarQuery: CalendarQuery,
 ): Promise<DeltaEntryInfosResponse> {
   // If we're not including deleted entries, we will try and set deletedEntryIDs
   // so that the client can catch possibly stale deleted entryInfos
   let filterDeleted = null;
   for (const calendarQuery of calendarQueries) {
     const notDeletedFilterExists = filterExists(
       calendarQuery.filters,
       calendarThreadFilterTypes.NOT_DELETED,
     );
     if (filterDeleted === null) {
       filterDeleted = notDeletedFilterExists;
     } else {
       invariant(
         filterDeleted === notDeletedFilterExists,
         'one of the CalendarQueries returned by calendarQueryDifference has ' +
           'a NOT_DELETED filter but another does not: ' +
           JSON.stringify(calendarQueries),
       );
     }
   }
 
   let calendarQueriesForFetch = calendarQueries;
   if (filterDeleted) {
     // Because in the filterDeleted case we still need the deleted RawEntryInfos
     // in order to construct deletedEntryIDs, we get rid of the NOT_DELETED
     // filters before passing the CalendarQueries to fetchEntryInfos. We will
     // filter out the deleted RawEntryInfos in a later step.
     calendarQueriesForFetch = calendarQueriesForFetch.map(calendarQuery => ({
       ...calendarQuery,
       filters: nonExcludeDeletedCalendarFilters(calendarQuery.filters),
     }));
   }
 
   const { rawEntryInfos } = await fetchEntryInfos(
     viewer,
     calendarQueriesForFetch,
   );
   const entryInfosNotInOldQuery = rawEntryInfos.filter(
     rawEntryInfo =>
       !rawEntryInfoWithinCalendarQuery(rawEntryInfo, oldCalendarQuery),
   );
   let filteredRawEntryInfos = entryInfosNotInOldQuery;
   let deletedEntryIDs = [];
   if (filterDeleted) {
     filteredRawEntryInfos = entryInfosNotInOldQuery.filter(
       rawEntryInfo => !rawEntryInfo.deleted,
     );
     deletedEntryIDs = entryInfosNotInOldQuery
       .filter(rawEntryInfo => rawEntryInfo.deleted)
       .map(rawEntryInfo => {
         const { id } = rawEntryInfo;
         invariant(
           id !== null && id !== undefined,
           'serverID should be set in fetchEntryInfos result',
         );
         return id;
       });
   }
 
   return {
     rawEntryInfos: filteredRawEntryInfos,
     deletedEntryIDs,
   };
 }
 
 async function fetchEntryInfoForLocalID(
   viewer: Viewer,
   localID: ?string,
 ): Promise<?RawEntryInfo> {
   if (!localID || !viewer.hasSessionInfo) {
     return null;
   }
   const creation = creationString(viewer, localID);
   const viewerID = viewer.id;
   const query = SQL`
     SELECT DAY(d.date) AS day, MONTH(d.date) AS month, YEAR(d.date) AS year,
       e.id, e.text, e.creation_time AS creationTime, d.thread AS threadID,
       e.deleted, e.creator AS creatorID
     FROM entries e
     LEFT JOIN days d ON d.id = e.day
     LEFT JOIN memberships m ON m.thread = d.thread AND m.user = ${viewerID}
     WHERE e.creator = ${viewerID} AND e.creation = ${creation} AND
       JSON_EXTRACT(m.permissions, ${visPermissionExtractString}) IS TRUE
   `;
 
   const [result] = await dbQuery(query);
   if (result.length === 0) {
     return null;
   }
   return rawEntryInfoFromRow(result[0]);
 }
 
 export {
   fetchEntryInfo,
   fetchEntryInfosByID,
   fetchEntryInfos,
   checkThreadPermissionForEntry,
   fetchEntryRevisionInfo,
   fetchEntriesForSession,
   fetchEntryInfoForLocalID,
 };
diff --git a/keyserver/src/fetchers/report-fetchers.js b/keyserver/src/fetchers/report-fetchers.js
index 486ca56ae..5e65e6332 100644
--- a/keyserver/src/fetchers/report-fetchers.js
+++ b/keyserver/src/fetchers/report-fetchers.js
@@ -1,108 +1,107 @@
 // @flow
 
 import { isStaff } from 'lib/shared/user-utils';
 import {
   type FetchErrorReportInfosResponse,
   type FetchErrorReportInfosRequest,
   type ReduxToolsImport,
   reportTypes,
 } from 'lib/types/report-types';
 import { ServerError } from 'lib/utils/errors';
 import { values } from 'lib/utils/objects';
 
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 import type { Viewer } from '../session/viewer';
 
 async function fetchErrorReportInfos(
   viewer: Viewer,
   request: FetchErrorReportInfosRequest,
 ): Promise<FetchErrorReportInfosResponse> {
   if (!viewer.loggedIn || !isStaff(viewer.userID)) {
     throw new ServerError('invalid_credentials');
   }
 
   const query = SQL`
     SELECT r.id, r.user, r.platform, r.report, r.creation_time, u.username
     FROM reports r
     LEFT JOIN users u ON u.id = r.user
   `;
   if (request.cursor) {
     query.append(SQL`WHERE r.id < ${request.cursor} `);
   }
   query.append(SQL`ORDER BY r.id DESC`);
-  const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+  const [result] = await dbQuery(query);
 
   const reports = [];
   const userInfos = {};
   for (const row of result) {
     const viewerID = row.user.toString();
-    const report = dbType === 'mysql5.7' ? row.report : JSON.parse(row.report);
+    const report = JSON.parse(row.report);
     let { platformDetails } = report;
     if (!platformDetails) {
       platformDetails = {
         platform: row.platform,
         codeVersion: report.codeVersion,
         stateVersion: report.stateVersion,
       };
     }
     reports.push({
       id: row.id.toString(),
       viewerID,
       platformDetails,
       creationTime: row.creation_time,
     });
     if (row.username) {
       userInfos[viewerID] = {
         id: viewerID,
         username: row.username,
       };
     }
   }
 
   return { reports, userInfos: values(userInfos) };
 }
 
 async function fetchReduxToolsImport(
   viewer: Viewer,
   id: string,
 ): Promise<ReduxToolsImport> {
   if (!viewer.loggedIn || !isStaff(viewer.userID)) {
     throw new ServerError('invalid_credentials');
   }
 
   const query = SQL`
     SELECT user, report, creation_time
     FROM reports
     WHERE id = ${id} AND type = ${reportTypes.ERROR}
   `;
-  const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+  const [result] = await dbQuery(query);
   if (result.length === 0) {
     throw new ServerError('invalid_parameters');
   }
   const row = result[0];
 
-  const report = dbType === 'mysql5.7' ? row.report : JSON.parse(row.report);
+  const report = JSON.parse(row.report);
   const _persist = report.preloadedState._persist
     ? report.preloadedState._persist
     : {};
   const navState =
     report.currentState && report.currentState.navState
       ? report.currentState.navState
       : undefined;
   return {
     preloadedState: {
       ...report.preloadedState,
       _persist: {
         ..._persist,
         // Setting this to false disables redux-persist
         rehydrated: false,
       },
       navState,
       frozen: true,
     },
     payload: report.actions,
   };
 }
 
 export { fetchErrorReportInfos, fetchReduxToolsImport };
diff --git a/keyserver/src/fetchers/role-fetchers.js b/keyserver/src/fetchers/role-fetchers.js
index eeeab6e52..43288e57a 100644
--- a/keyserver/src/fetchers/role-fetchers.js
+++ b/keyserver/src/fetchers/role-fetchers.js
@@ -1,30 +1,28 @@
 // @flow
 
 import type { RoleInfo } from 'lib/types/thread-types';
 
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 
 async function fetchRoles(threadID: string): Promise<RoleInfo[]> {
   const query = SQL`
     SELECT r.id, r.name, r.permissions, r.id = t.default_role AS is_default
     FROM roles r
     LEFT JOIN threads t ON t.id = r.thread
     WHERE r.thread = ${threadID}
   `;
-  const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+  const [result] = await dbQuery(query);
 
   const roles = [];
   for (const row of result) {
     roles.push({
       id: row.id.toString(),
       name: row.name,
-      permissions:
-        dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions),
+      permissions: JSON.parse(row.permissions),
       isDefault: Boolean(row.is_default),
     });
   }
   return roles;
 }
 
 export { fetchRoles };
diff --git a/keyserver/src/fetchers/session-fetchers.js b/keyserver/src/fetchers/session-fetchers.js
index 905d7debc..b3d77bc89 100644
--- a/keyserver/src/fetchers/session-fetchers.js
+++ b/keyserver/src/fetchers/session-fetchers.js
@@ -1,46 +1,45 @@
 // @flow
 
 import type { CalendarQuery } from 'lib/types/entry-types';
 
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 import type { Viewer } from '../session/viewer';
 
 type CalendarSessionResult = {
   userID: string,
   session: string,
   calendarQuery: CalendarQuery,
 };
 async function fetchActiveSessionsForThread(
   threadID: string,
 ): Promise<CalendarSessionResult[]> {
   const query = SQL`
     SELECT s.id, s.user, s.query
     FROM memberships m
     LEFT JOIN sessions s ON s.user = m.user
     WHERE m.thread = ${threadID} AND m.role > 0
       AND s.query IS NOT NULL
   `;
-  const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+  const [result] = await dbQuery(query);
   const filters = [];
   for (const row of result) {
     filters.push({
       userID: row.user.toString(),
       session: row.id.toString(),
-      calendarQuery: dbType === 'mysql5.7' ? row.query : JSON.parse(row.query),
+      calendarQuery: JSON.parse(row.query),
     });
   }
   return filters;
 }
 
 async function fetchOtherSessionsForViewer(viewer: Viewer): Promise<string[]> {
   const query = SQL`
     SELECT id
     FROM sessions
     WHERE user = ${viewer.userID} AND id != ${viewer.session}
   `;
   const [result] = await dbQuery(query);
   return result.map(row => row.id.toString());
 }
 
 export { fetchActiveSessionsForThread, fetchOtherSessionsForViewer };
diff --git a/keyserver/src/fetchers/thread-fetchers.js b/keyserver/src/fetchers/thread-fetchers.js
index 9b3978937..0ab8e0509 100644
--- a/keyserver/src/fetchers/thread-fetchers.js
+++ b/keyserver/src/fetchers/thread-fetchers.js
@@ -1,231 +1,224 @@
 // @flow
 
 import { getAllThreadPermissions } from 'lib/permissions/thread-permissions';
 import {
   rawThreadInfoFromServerThreadInfo,
   getContainingThreadID,
   getCommunity,
 } from 'lib/shared/thread-utils';
 import { hasMinCodeVersion } from 'lib/shared/version-utils';
 import {
   threadTypes,
   type ThreadType,
   type RawThreadInfo,
   type ServerThreadInfo,
 } from 'lib/types/thread-types';
 import { ServerError } from 'lib/utils/errors';
 
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 import type { SQLStatementType } from '../database/types';
 import type { Viewer } from '../session/viewer';
 
 type FetchServerThreadInfosResult = {
   +threadInfos: { +[id: string]: ServerThreadInfo },
 };
 
 async function fetchServerThreadInfos(
   condition?: SQLStatementType,
 ): Promise<FetchServerThreadInfosResult> {
   const whereClause = condition ? SQL`WHERE `.append(condition) : '';
 
   const query = SQL`
     SELECT t.id, t.name, t.parent_thread_id, t.containing_thread_id,
       t.community, t.depth, t.color, t.description, t.type, t.creation_time,
       t.default_role, t.source_message, t.replies_count, r.id AS role,
       r.name AS role_name, r.permissions AS role_permissions, m.user,
       m.permissions, m.subscription,
       m.last_read_message < m.last_message AS unread, m.sender
     FROM threads t
     LEFT JOIN (
         SELECT thread, id, name, permissions
           FROM roles
         UNION SELECT id AS thread, 0 AS id, NULL AS name, NULL AS permissions
           FROM threads
       ) r ON r.thread = t.id
     LEFT JOIN memberships m ON m.role = r.id AND m.thread = t.id AND
       m.role >= 0
   `
     .append(whereClause)
     .append(SQL` ORDER BY m.user ASC`);
-  const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+  const [result] = await dbQuery(query);
 
   const threadInfos = {};
   for (const row of result) {
     const threadID = row.id.toString();
     if (!threadInfos[threadID]) {
       threadInfos[threadID] = {
         id: threadID,
         type: row.type,
         name: row.name ? row.name : '',
         description: row.description ? row.description : '',
         color: row.color,
         creationTime: row.creation_time,
         parentThreadID: row.parent_thread_id
           ? row.parent_thread_id.toString()
           : null,
         containingThreadID: row.containing_thread_id
           ? row.containing_thread_id.toString()
           : null,
         depth: row.depth,
         community: row.community ? row.community.toString() : null,
         members: [],
         roles: {},
         repliesCount: row.replies_count,
       };
     }
     const sourceMessageID = row.source_message?.toString();
     if (sourceMessageID) {
       threadInfos[threadID].sourceMessageID = sourceMessageID;
     }
     const role = row.role.toString();
     if (row.role && !threadInfos[threadID].roles[role]) {
       threadInfos[threadID].roles[role] = {
         id: role,
         name: row.role_name,
-        permissions:
-          dbType === 'mysql5.7'
-            ? row.role_permissions
-            : JSON.parse(row.role_permissions),
+        permissions: JSON.parse(row.role_permissions),
         isDefault: role === row.default_role.toString(),
       };
     }
     if (row.user) {
       const userID = row.user.toString();
       const allPermissions = getAllThreadPermissions(
-        dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions),
+        JSON.parse(row.permissions),
         threadID,
       );
       threadInfos[threadID].members.push({
         id: userID,
         permissions: allPermissions,
         role: row.role ? role : null,
-        subscription:
-          dbType === 'mysql5.7'
-            ? row.subscription
-            : JSON.parse(row.subscription),
+        subscription: JSON.parse(row.subscription),
         unread: row.role ? !!row.unread : null,
         isSender: !!row.sender,
       });
     }
   }
   return { threadInfos };
 }
 
 export type FetchThreadInfosResult = {
   +threadInfos: { +[id: string]: RawThreadInfo },
 };
 
 async function fetchThreadInfos(
   viewer: Viewer,
   condition?: SQLStatementType,
 ): Promise<FetchThreadInfosResult> {
   const serverResult = await fetchServerThreadInfos(condition);
   return rawThreadInfosFromServerThreadInfos(viewer, serverResult);
 }
 
 const shimCommunityRoot = {
   [threadTypes.COMMUNITY_ROOT]: threadTypes.COMMUNITY_SECRET_SUBTHREAD,
   [threadTypes.COMMUNITY_ANNOUNCEMENT_ROOT]:
     threadTypes.COMMUNITY_SECRET_SUBTHREAD,
   [threadTypes.COMMUNITY_OPEN_ANNOUNCEMENT_SUBTHREAD]:
     threadTypes.COMMUNITY_OPEN_SUBTHREAD,
   [threadTypes.COMMUNITY_SECRET_ANNOUNCEMENT_SUBTHREAD]:
     threadTypes.COMMUNITY_SECRET_SUBTHREAD,
   [threadTypes.GENESIS]: threadTypes.COMMUNITY_SECRET_SUBTHREAD,
 };
 
 function rawThreadInfosFromServerThreadInfos(
   viewer: Viewer,
   serverResult: FetchServerThreadInfosResult,
 ): FetchThreadInfosResult {
   const viewerID = viewer.id;
   const hasCodeVersionBelow70 = !hasMinCodeVersion(viewer.platformDetails, 70);
   const hasCodeVersionBelow87 = !hasMinCodeVersion(viewer.platformDetails, 87);
   const hasCodeVersionBelow102 = !hasMinCodeVersion(
     viewer.platformDetails,
     102,
   );
   const hasCodeVersionBelow104 = !hasMinCodeVersion(
     viewer.platformDetails,
     104,
   );
   const threadInfos = {};
   for (const threadID in serverResult.threadInfos) {
     const serverThreadInfo = serverResult.threadInfos[threadID];
     const threadInfo = rawThreadInfoFromServerThreadInfo(
       serverThreadInfo,
       viewerID,
       {
         includeVisibilityRules: hasCodeVersionBelow70,
         filterMemberList: hasCodeVersionBelow70,
         shimThreadTypes: hasCodeVersionBelow87 ? shimCommunityRoot : null,
         hideThreadStructure: hasCodeVersionBelow102,
         filterDetailedThreadEditPermissions: hasCodeVersionBelow104,
       },
     );
     if (threadInfo) {
       threadInfos[threadID] = threadInfo;
     }
   }
   return { threadInfos };
 }
 
 async function verifyThreadIDs(
   threadIDs: $ReadOnlyArray<string>,
 ): Promise<$ReadOnlyArray<string>> {
   if (threadIDs.length === 0) {
     return [];
   }
 
   const query = SQL`SELECT id FROM threads WHERE id IN (${threadIDs})`;
   const [result] = await dbQuery(query);
 
   const verified = [];
   for (const row of result) {
     verified.push(row.id.toString());
   }
   return verified;
 }
 
 async function verifyThreadID(threadID: string): Promise<boolean> {
   const result = await verifyThreadIDs([threadID]);
   return result.length !== 0;
 }
 
 type ThreadAncestry = {
   +containingThreadID: ?string,
   +community: ?string,
   +depth: number,
 };
 async function determineThreadAncestry(
   parentThreadID: ?string,
   threadType: ThreadType,
 ): Promise<ThreadAncestry> {
   if (!parentThreadID) {
     return { containingThreadID: null, community: null, depth: 0 };
   }
   const parentThreadInfos = await fetchServerThreadInfos(
     SQL`t.id = ${parentThreadID}`,
   );
   const parentThreadInfo = parentThreadInfos.threadInfos[parentThreadID];
   if (!parentThreadInfo) {
     throw new ServerError('invalid_parameters');
   }
   const containingThreadID = getContainingThreadID(
     parentThreadInfo,
     threadType,
   );
   const community = getCommunity(parentThreadInfo);
   const depth = parentThreadInfo.depth + 1;
   return { containingThreadID, community, depth };
 }
 
 export {
   fetchServerThreadInfos,
   fetchThreadInfos,
   rawThreadInfosFromServerThreadInfos,
   verifyThreadIDs,
   verifyThreadID,
   determineThreadAncestry,
 };
diff --git a/keyserver/src/fetchers/thread-permission-fetchers.js b/keyserver/src/fetchers/thread-permission-fetchers.js
index e10f0086b..025dc585d 100644
--- a/keyserver/src/fetchers/thread-permission-fetchers.js
+++ b/keyserver/src/fetchers/thread-permission-fetchers.js
@@ -1,373 +1,366 @@
 // @flow
 
 import {
   permissionLookup,
   makePermissionsBlob,
   getRoleForPermissions,
 } from 'lib/permissions/thread-permissions';
 import { relationshipBlockedInEitherDirection } from 'lib/shared/relationship-utils';
 import {
   threadFrozenDueToBlock,
   permissionsDisabledByBlock,
 } from 'lib/shared/thread-utils';
 import { userRelationshipStatus } from 'lib/types/relationship-types';
 import type {
   ThreadType,
   ThreadPermission,
   ThreadPermissionsBlob,
   ThreadRolePermissionsBlob,
 } from 'lib/types/thread-types';
 
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 import type { Viewer } from '../session/viewer';
 import { fetchThreadInfos } from './thread-fetchers';
 import { fetchKnownUserInfos } from './user-fetchers';
 
 // Note that it's risky to verify permissions by inspecting the blob directly.
 // There are other factors that can override permissions in the permissions
 // blob, such as when one user blocks another. It's always better to go through
 // checkThreads and friends, or by looking at the ThreadInfo through
 // threadHasPermission.
 async function fetchThreadPermissionsBlob(
   viewer: Viewer,
   threadID: string,
 ): Promise<?ThreadPermissionsBlob> {
   const viewerID = viewer.id;
   const query = SQL`
     SELECT permissions
     FROM memberships
     WHERE thread = ${threadID} AND user = ${viewerID}
   `;
-  const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+  const [result] = await dbQuery(query);
 
   if (result.length === 0) {
     return null;
   }
   const row = result[0];
-  return dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions);
+  return JSON.parse(row.permissions);
 }
 
 function checkThreadPermission(
   viewer: Viewer,
   threadID: string,
   permission: ThreadPermission,
 ): Promise<boolean> {
   return checkThread(viewer, threadID, [{ check: 'permission', permission }]);
 }
 
 function viewerIsMember(viewer: Viewer, threadID: string): Promise<boolean> {
   return checkThread(viewer, threadID, [{ check: 'is_member' }]);
 }
 
 type Check =
   | { +check: 'is_member' }
   | { +check: 'permission', +permission: ThreadPermission };
 
 function isThreadValid(
   permissions: ?ThreadPermissionsBlob,
   role: number,
   checks: $ReadOnlyArray<Check>,
 ): boolean {
   for (const check of checks) {
     if (check.check === 'is_member') {
       if (role <= 0) {
         return false;
       }
     } else if (check.check === 'permission') {
       if (!permissionLookup(permissions, check.permission)) {
         return false;
       }
     }
   }
   return true;
 }
 
 async function checkThreads(
   viewer: Viewer,
   threadIDs: $ReadOnlyArray<string>,
   checks: $ReadOnlyArray<Check>,
 ): Promise<Set<string>> {
   if (viewer.isScriptViewer) {
     // script viewers are all-powerful
     return new Set(threadIDs);
   }
 
   const threadRows = await getValidThreads(viewer, threadIDs, checks);
   return new Set(threadRows.map(row => row.threadID));
 }
 
 type PartialMembershipRow = {
   +threadID: string,
   +role: number,
   +permissions: ThreadPermissionsBlob,
 };
 async function getValidThreads(
   viewer: Viewer,
   threadIDs: $ReadOnlyArray<string>,
   checks: $ReadOnlyArray<Check>,
 ): Promise<PartialMembershipRow[]> {
   const query = SQL`
     SELECT thread AS threadID, permissions, role
     FROM memberships
     WHERE thread IN (${threadIDs}) AND user = ${viewer.userID}
   `;
 
   const permissionsToCheck = [];
   for (const check of checks) {
     if (check.check === 'permission') {
       permissionsToCheck.push(check.permission);
     }
   }
 
-  const [[result], dbType, disabledThreadIDs] = await Promise.all([
+  const [[result], disabledThreadIDs] = await Promise.all([
     dbQuery(query),
-    getDBType(),
     checkThreadsFrozen(viewer, permissionsToCheck, threadIDs),
   ]);
 
   return result
     .map(row => ({
       ...row,
       threadID: row.threadID.toString(),
-      permissions:
-        dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions),
+      permissions: JSON.parse(row.permissions),
     }))
     .filter(
       row =>
         isThreadValid(row.permissions, row.role, checks) &&
         !disabledThreadIDs.has(row.threadID),
     );
 }
 
 async function checkThreadsFrozen(
   viewer: Viewer,
   permissionsToCheck: $ReadOnlyArray<ThreadPermission>,
   threadIDs: $ReadOnlyArray<string>,
 ) {
   const threadIDsWithDisabledPermissions = new Set();
 
   const permissionMightBeDisabled = permissionsToCheck.some(permission =>
     permissionsDisabledByBlock.has(permission),
   );
   if (!permissionMightBeDisabled) {
     return threadIDsWithDisabledPermissions;
   }
 
   const [{ threadInfos }, userInfos] = await Promise.all([
     fetchThreadInfos(viewer, SQL`t.id IN (${[...threadIDs]})`),
     fetchKnownUserInfos(viewer),
   ]);
 
   for (const threadID in threadInfos) {
     const blockedThread = threadFrozenDueToBlock(
       threadInfos[threadID],
       viewer.id,
       userInfos,
     );
     if (blockedThread) {
       threadIDsWithDisabledPermissions.add(threadID);
     }
   }
   return threadIDsWithDisabledPermissions;
 }
 
 async function checkIfThreadIsBlocked(
   viewer: Viewer,
   threadID: string,
   permission: ThreadPermission,
 ): Promise<boolean> {
   const disabledThreadIDs = await checkThreadsFrozen(
     viewer,
     [permission],
     [threadID],
   );
 
   return disabledThreadIDs.has(threadID);
 }
 
 async function checkThread(
   viewer: Viewer,
   threadID: string,
   checks: $ReadOnlyArray<Check>,
 ): Promise<boolean> {
   const validThreads = await checkThreads(viewer, [threadID], checks);
   return validThreads.has(threadID);
 }
 
 // We pass this into getRoleForPermissions in order to check if a hypothetical
 // permissions blob would block membership by returning a non-positive result.
 // It doesn't matter what value we pass in, as long as it's positive.
 const arbitraryPositiveRole = '1';
 
 type CandidateMembers = {
   +[key: string]: ?$ReadOnlyArray<string>,
   ...
 };
 type ValidateCandidateMembersParams = {
   +threadType: ThreadType,
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +defaultRolePermissions: ThreadRolePermissionsBlob,
 };
 type ValidateCandidateMembersOptions = { +requireRelationship?: boolean };
 async function validateCandidateMembers(
   viewer: Viewer,
   candidates: CandidateMembers,
   params: ValidateCandidateMembersParams,
   options?: ValidateCandidateMembersOptions,
 ): Promise<CandidateMembers> {
   const requireRelationship = options?.requireRelationship ?? true;
 
   const allCandidatesSet = new Set();
   for (const key in candidates) {
     const candidateGroup = candidates[key];
     if (!candidateGroup) {
       continue;
     }
     for (const candidate of candidateGroup) {
       allCandidatesSet.add(candidate);
     }
   }
   const allCandidates = [...allCandidatesSet];
 
   const fetchMembersPromise = fetchKnownUserInfos(viewer, allCandidates);
 
   const parentPermissionsPromise = (async () => {
     const parentPermissions = {};
     if (!params.parentThreadID || allCandidates.length === 0) {
       return parentPermissions;
     }
     const parentPermissionsQuery = SQL`
       SELECT user, permissions
       FROM memberships
       WHERE thread = ${params.parentThreadID} AND user IN (${allCandidates})
     `;
-    const [[result], dbType] = await Promise.all([
-      dbQuery(parentPermissionsQuery),
-      getDBType(),
-    ]);
+    const [result] = await dbQuery(parentPermissionsQuery);
     for (const row of result) {
-      parentPermissions[row.user.toString()] =
-        dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions);
+      parentPermissions[row.user.toString()] = JSON.parse(row.permissions);
     }
     return parentPermissions;
   })();
 
   const memberOfContainingThreadPromise: Promise<
     Map<string, 'member' | 'non-member' | 'no-containing-thread'>,
   > = (async () => {
     const results = new Map();
     if (allCandidates.length === 0) {
       return results;
     }
     if (!params.containingThreadID) {
       for (const userID of allCandidates) {
         results.set(userID, 'no-containing-thread');
       }
       return results;
     }
     const memberOfContainingThreadQuery = SQL`
       SELECT user, role AS containing_role
       FROM memberships
       WHERE thread = ${params.containingThreadID} AND user IN (${allCandidates})
     `;
     const [result] = await dbQuery(memberOfContainingThreadQuery);
     for (const row of result) {
       results.set(
         row.user.toString(),
         row.containing_role > 0 ? 'member' : 'non-member',
       );
     }
     return results;
   })();
 
   const [
     fetchedMembers,
     parentPermissions,
     memberOfContainingThread,
   ] = await Promise.all([
     fetchMembersPromise,
     parentPermissionsPromise,
     memberOfContainingThreadPromise,
   ]);
 
   const ignoreMembers = new Set();
   for (const memberID of allCandidates) {
     const member = fetchedMembers[memberID];
     if (!member && requireRelationship) {
       ignoreMembers.add(memberID);
       continue;
     }
     const relationshipStatus = member?.relationshipStatus;
     const memberRelationshipHasBlock = !!(
       relationshipStatus &&
       relationshipBlockedInEitherDirection(relationshipStatus)
     );
     if (memberRelationshipHasBlock) {
       ignoreMembers.add(memberID);
       continue;
     }
     const permissionsFromParent = parentPermissions[memberID];
     if (memberOfContainingThread.get(memberID) === 'non-member') {
       ignoreMembers.add(memberID);
       continue;
     }
     if (
       memberOfContainingThread.get(memberID) === 'no-containing-thread' &&
       relationshipStatus !== userRelationshipStatus.FRIEND &&
       requireRelationship
     ) {
       ignoreMembers.add(memberID);
       continue;
     }
     const permissions = makePermissionsBlob(
       params.defaultRolePermissions,
       permissionsFromParent,
       '-1',
       params.threadType,
     );
     if (!permissions) {
       ignoreMembers.add(memberID);
       continue;
     }
     const targetRole = getRoleForPermissions(
       arbitraryPositiveRole,
       permissions,
     );
     if (Number(targetRole) <= 0) {
       ignoreMembers.add(memberID);
       continue;
     }
   }
   if (ignoreMembers.size === 0) {
     return candidates;
   }
 
   const result = {};
   for (const key in candidates) {
     const candidateGroup = candidates[key];
     if (!candidateGroup) {
       result[key] = candidates[key];
       continue;
     }
     result[key] = [];
     for (const candidate of candidateGroup) {
       if (!ignoreMembers.has(candidate)) {
         result[key].push(candidate);
       }
     }
   }
   return result;
 }
 
 export {
   fetchThreadPermissionsBlob,
   checkThreadPermission,
   viewerIsMember,
   checkThreads,
   getValidThreads,
   checkThread,
   checkIfThreadIsBlocked,
   validateCandidateMembers,
 };
diff --git a/keyserver/src/push/rescind.js b/keyserver/src/push/rescind.js
index 17063b836..6b675c600 100644
--- a/keyserver/src/push/rescind.js
+++ b/keyserver/src/push/rescind.js
@@ -1,229 +1,224 @@
 // @flow
 
 import apn from '@parse/node-apn';
 import invariant from 'invariant';
 
 import { threadSubscriptions } from 'lib/types/subscription-types';
 import { threadPermissions } from 'lib/types/thread-types';
 import { promiseAll } from 'lib/utils/promises';
 
 import createIDs from '../creators/id-creator';
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 import type { SQLStatementType } from '../database/types';
 import { getAPNsNotificationTopic } from './providers';
 import { apnPush, fcmPush } from './utils';
 
 // Returns list of deviceTokens that have been updated
 async function rescindPushNotifs(
   notifCondition: SQLStatementType,
   inputCountCondition?: SQLStatementType,
 ): Promise<string[]> {
   const notificationExtractString = `$.${threadSubscriptions.home}`;
   const visPermissionExtractString = `$.${threadPermissions.VISIBLE}.value`;
   const fetchQuery = SQL`
     SELECT n.id, n.user, n.thread, n.message, n.delivery, n.collapse_key, COUNT(
   `;
   fetchQuery.append(inputCountCondition ? inputCountCondition : SQL`m.thread`);
   fetchQuery.append(SQL`
       ) AS unread_count
     FROM notifications n
     LEFT JOIN memberships m ON m.user = n.user 
       AND m.last_message > m.last_read_message 
       AND m.role > 0 
       AND JSON_EXTRACT(subscription, ${notificationExtractString})
       AND JSON_EXTRACT(permissions, ${visPermissionExtractString})
     WHERE n.rescinded = 0 AND
   `);
   fetchQuery.append(notifCondition);
   fetchQuery.append(SQL` GROUP BY n.id, m.user`);
-  const [[fetchResult], dbType] = await Promise.all([
-    dbQuery(fetchQuery),
-    getDBType(),
-  ]);
+  const [fetchResult] = await dbQuery(fetchQuery);
 
   const deliveryPromises = {};
   const notifInfo = {};
   const rescindedIDs = [];
   const receivingDeviceTokens = [];
   for (const row of fetchResult) {
-    const rawDelivery =
-      dbType === 'mysql5.7' ? row.delivery : JSON.parse(row.delivery);
+    const rawDelivery = JSON.parse(row.delivery);
     const deliveries = Array.isArray(rawDelivery) ? rawDelivery : [rawDelivery];
     const id = row.id.toString();
     const threadID = row.thread.toString();
     notifInfo[id] = {
       userID: row.user.toString(),
       threadID,
       messageID: row.message.toString(),
     };
     for (const delivery of deliveries) {
       if (delivery.iosID && delivery.iosDeviceTokens) {
         // Old iOS
         const notification = prepareIOSNotification(
           delivery.iosID,
           row.unread_count,
           threadID,
         );
         deliveryPromises[id] = apnPush({
           notification,
           deviceTokens: delivery.iosDeviceTokens,
           codeVersion: null,
         });
         receivingDeviceTokens.push(...delivery.iosDeviceTokens);
       } else if (delivery.androidID) {
         // Old Android
         const notification = prepareAndroidNotification(
           row.collapse_key ? row.collapse_key : id,
           row.unread_count,
           threadID,
           null,
         );
         deliveryPromises[id] = fcmPush({
           notification,
           deviceTokens: delivery.androidDeviceTokens,
           codeVersion: null,
         });
         receivingDeviceTokens.push(...delivery.androidDeviceTokens);
       } else if (delivery.deviceType === 'ios') {
         // New iOS
         const { iosID, deviceTokens, codeVersion } = delivery;
         const notification = prepareIOSNotification(
           iosID,
           row.unread_count,
           threadID,
           codeVersion,
         );
         deliveryPromises[id] = apnPush({
           notification,
           deviceTokens,
           codeVersion,
         });
         receivingDeviceTokens.push(...deviceTokens);
       } else if (delivery.deviceType === 'android') {
         // New Android
         const { deviceTokens, codeVersion } = delivery;
         const notification = prepareAndroidNotification(
           row.collapse_key ? row.collapse_key : id,
           row.unread_count,
           threadID,
           codeVersion,
         );
         deliveryPromises[id] = fcmPush({
           notification,
           deviceTokens,
           codeVersion,
         });
         receivingDeviceTokens.push(...deviceTokens);
       }
     }
     rescindedIDs.push(row.id);
   }
 
   const numRescinds = Object.keys(deliveryPromises).length;
   const promises = [promiseAll(deliveryPromises)];
   if (numRescinds > 0) {
     promises.push(createIDs('notifications', numRescinds));
   }
   if (rescindedIDs.length > 0) {
     const rescindQuery = SQL`
       UPDATE notifications SET rescinded = 1 WHERE id IN (${rescindedIDs})
     `;
     promises.push(dbQuery(rescindQuery));
   }
 
   const [deliveryResults, dbIDs] = await Promise.all(promises);
   const newNotifRows = [];
   if (numRescinds > 0) {
     invariant(dbIDs, 'dbIDs should be set');
     for (const rescindedID in deliveryResults) {
       const delivery = {};
       delivery.source = 'rescind';
       delivery.rescindedID = rescindedID;
       const { errors } = deliveryResults[rescindedID];
       if (errors) {
         delivery.errors = errors;
       }
       const dbID = dbIDs.shift();
       const { userID, threadID, messageID } = notifInfo[rescindedID];
       newNotifRows.push([
         dbID,
         userID,
         threadID,
         messageID,
         null,
         JSON.stringify([delivery]),
         1,
       ]);
     }
   }
   if (newNotifRows.length > 0) {
     const insertQuery = SQL`
       INSERT INTO notifications
         (id, user, thread, message, collapse_key, delivery, rescinded)
       VALUES ${newNotifRows}
     `;
     await dbQuery(insertQuery);
   }
 
   return [...new Set(receivingDeviceTokens)];
 }
 
 function prepareIOSNotification(
   iosID: string,
   unreadCount: number,
   threadID: string,
   codeVersion: ?number,
 ): apn.Notification {
   const notification = new apn.Notification();
   notification.contentAvailable = true;
   notification.badge = unreadCount;
   notification.topic = getAPNsNotificationTopic(codeVersion);
   notification.priority = 5;
   notification.pushType = 'background';
   notification.payload =
     codeVersion && codeVersion > 135
       ? {
           backgroundNotifType: 'CLEAR',
           notificationId: iosID,
           setUnreadStatus: true,
           threadID,
         }
       : {
           managedAps: {
             action: 'CLEAR',
             notificationId: iosID,
           },
         };
   return notification;
 }
 
 function prepareAndroidNotification(
   notifID: string,
   unreadCount: number,
   threadID: string,
   codeVersion: ?number,
 ): Object {
   if (!codeVersion || codeVersion < 31) {
     return {
       data: {
         badge: unreadCount.toString(),
         custom_notification: JSON.stringify({
           rescind: 'true',
           notifID,
         }),
       },
     };
   }
   return {
     data: {
       badge: unreadCount.toString(),
       rescind: 'true',
       rescindID: notifID,
       setUnreadStatus: 'true',
       threadID,
     },
   };
 }
 
 export { rescindPushNotifs };
diff --git a/keyserver/src/push/send.js b/keyserver/src/push/send.js
index f0c64ba69..24ce3030e 100644
--- a/keyserver/src/push/send.js
+++ b/keyserver/src/push/send.js
@@ -1,841 +1,831 @@
 // @flow
 
 import apn from '@parse/node-apn';
 import type { ResponseFailure } from '@parse/node-apn';
 import invariant from 'invariant';
 import _cloneDeep from 'lodash/fp/cloneDeep';
 import _flow from 'lodash/fp/flow';
 import _mapValues from 'lodash/fp/mapValues';
 import _pickBy from 'lodash/fp/pickBy';
 import uuidv4 from 'uuid/v4';
 
 import { oldValidUsernameRegex } from 'lib/shared/account-utils';
 import {
   createMessageInfo,
   sortMessageInfoList,
   shimUnsupportedRawMessageInfos,
 } from 'lib/shared/message-utils';
 import { messageSpecs } from 'lib/shared/messages/message-specs';
 import { notifTextsForMessageInfo } from 'lib/shared/notif-utils';
 import {
   rawThreadInfoFromServerThreadInfo,
   threadInfoFromRawThreadInfo,
 } from 'lib/shared/thread-utils';
 import type { DeviceType } from 'lib/types/device-types';
 import {
   type RawMessageInfo,
   type MessageInfo,
   messageTypes,
 } from 'lib/types/message-types';
 import type { ServerThreadInfo, ThreadInfo } from 'lib/types/thread-types';
 import { updateTypes } from 'lib/types/update-types';
 import { promiseAll } from 'lib/utils/promises';
 
 import createIDs from '../creators/id-creator';
 import { createUpdates } from '../creators/update-creator';
 import { dbQuery, SQL, mergeOrConditions } from '../database/database';
-import { getDBType } from '../database/db-config';
 import type { CollapsableNotifInfo } from '../fetchers/message-fetchers';
 import { fetchCollapsableNotifs } from '../fetchers/message-fetchers';
 import { fetchServerThreadInfos } from '../fetchers/thread-fetchers';
 import { fetchUserInfos } from '../fetchers/user-fetchers';
 import type { Viewer } from '../session/viewer';
 import { getAPNsNotificationTopic } from './providers';
 import {
   apnPush,
   fcmPush,
   getUnreadCounts,
   apnMaxNotificationPayloadByteSize,
 } from './utils';
 
 type Device = {
   +deviceType: DeviceType,
   +deviceToken: string,
   +codeVersion: ?number,
 };
 type PushUserInfo = {
   +devices: Device[],
   +messageInfos: RawMessageInfo[],
 };
 type Delivery = IOSDelivery | AndroidDelivery | { collapsedInto: string };
 type NotificationRow = {
   +dbID: string,
   +userID: string,
   +threadID?: ?string,
   +messageID?: ?string,
   +collapseKey?: ?string,
   +deliveries: Delivery[],
 };
 export type PushInfo = { [userID: string]: PushUserInfo };
 
 async function sendPushNotifs(pushInfo: PushInfo) {
   if (Object.keys(pushInfo).length === 0) {
     return;
   }
 
   const [
     unreadCounts,
     { usersToCollapsableNotifInfo, serverThreadInfos, userInfos },
     dbIDs,
   ] = await Promise.all([
     getUnreadCounts(Object.keys(pushInfo)),
     fetchInfos(pushInfo),
     createDBIDs(pushInfo),
   ]);
 
   const deliveryPromises = [];
   const notifications: Map<string, NotificationRow> = new Map();
   for (const userID in usersToCollapsableNotifInfo) {
     const threadInfos = _flow(
       _mapValues((serverThreadInfo: ServerThreadInfo) => {
         const rawThreadInfo = rawThreadInfoFromServerThreadInfo(
           serverThreadInfo,
           userID,
         );
         if (!rawThreadInfo) {
           return null;
         }
         return threadInfoFromRawThreadInfo(rawThreadInfo, userID, userInfos);
       }),
       _pickBy(threadInfo => threadInfo),
     )(serverThreadInfos);
     for (const notifInfo of usersToCollapsableNotifInfo[userID]) {
       const hydrateMessageInfo = (rawMessageInfo: RawMessageInfo) =>
         createMessageInfo(rawMessageInfo, userID, userInfos, threadInfos);
       const newMessageInfos = [];
       const newRawMessageInfos = [];
       for (const newRawMessageInfo of notifInfo.newMessageInfos) {
         const newMessageInfo = hydrateMessageInfo(newRawMessageInfo);
         if (newMessageInfo) {
           newMessageInfos.push(newMessageInfo);
           newRawMessageInfos.push(newRawMessageInfo);
         }
       }
       if (newMessageInfos.length === 0) {
         continue;
       }
       const existingMessageInfos = notifInfo.existingMessageInfos
         .map(hydrateMessageInfo)
         .filter(Boolean);
       const allMessageInfos = sortMessageInfoList([
         ...newMessageInfos,
         ...existingMessageInfos,
       ]);
       const [
         firstNewMessageInfo,
         ...remainingNewMessageInfos
       ] = newMessageInfos;
       const threadID = firstNewMessageInfo.threadID;
 
       const threadInfo = threadInfos[threadID];
       const updateBadge = threadInfo.currentUser.subscription.home;
       const displayBanner = threadInfo.currentUser.subscription.pushNotifs;
       const username = userInfos[userID] && userInfos[userID].username;
       const userWasMentioned =
         username &&
         threadInfo.currentUser.role &&
         oldValidUsernameRegex.test(username) &&
         firstNewMessageInfo.type === messageTypes.TEXT &&
         new RegExp(`\\B@${username}\\b`, 'i').test(firstNewMessageInfo.text);
       if (!updateBadge && !displayBanner && !userWasMentioned) {
         continue;
       }
       const badgeOnly = !displayBanner && !userWasMentioned;
 
       const dbID = dbIDs.shift();
       invariant(dbID, 'should have sufficient DB IDs');
       const byDeviceType = getDevicesByDeviceType(pushInfo[userID].devices);
       const firstMessageID = firstNewMessageInfo.id;
       invariant(firstMessageID, 'RawMessageInfo.id should be set on server');
       const notificationInfo = {
         source: 'new_message',
         dbID,
         userID,
         threadID,
         messageID: firstMessageID,
         collapseKey: notifInfo.collapseKey,
       };
 
       const iosVersionsToTokens = byDeviceType.get('ios');
       if (iosVersionsToTokens) {
         for (const [codeVer, deviceTokens] of iosVersionsToTokens) {
           const codeVersion = parseInt(codeVer, 10); // only for Flow
           const shimmedNewRawMessageInfos = shimUnsupportedRawMessageInfos(
             newRawMessageInfos,
             { platform: 'ios', codeVersion },
           );
           const notification = prepareIOSNotification(
             allMessageInfos,
             shimmedNewRawMessageInfos,
             threadInfo,
             notifInfo.collapseKey,
             badgeOnly,
             unreadCounts[userID],
             codeVersion,
           );
           deliveryPromises.push(
             sendIOSNotification(notification, [...deviceTokens], {
               ...notificationInfo,
               codeVersion,
             }),
           );
         }
       }
       const androidVersionsToTokens = byDeviceType.get('android');
       if (androidVersionsToTokens) {
         for (const [codeVer, deviceTokens] of androidVersionsToTokens) {
           const codeVersion = parseInt(codeVer, 10); // only for Flow
           const shimmedNewRawMessageInfos = shimUnsupportedRawMessageInfos(
             newRawMessageInfos,
             { platform: 'android', codeVersion },
           );
           const notification = prepareAndroidNotification(
             allMessageInfos,
             shimmedNewRawMessageInfos,
             threadInfo,
             notifInfo.collapseKey,
             badgeOnly,
             unreadCounts[userID],
             dbID,
             codeVersion,
           );
           deliveryPromises.push(
             sendAndroidNotification(notification, [...deviceTokens], {
               ...notificationInfo,
               codeVersion,
             }),
           );
         }
       }
 
       for (const newMessageInfo of remainingNewMessageInfos) {
         const newDBID = dbIDs.shift();
         invariant(newDBID, 'should have sufficient DB IDs');
         const messageID = newMessageInfo.id;
         invariant(messageID, 'RawMessageInfo.id should be set on server');
         notifications.set(newDBID, {
           dbID: newDBID,
           userID,
           threadID: newMessageInfo.threadID,
           messageID,
           collapseKey: notifInfo.collapseKey,
           deliveries: [{ collapsedInto: dbID }],
         });
       }
     }
   }
 
   const cleanUpPromises = [];
   if (dbIDs.length > 0) {
     const query = SQL`DELETE FROM ids WHERE id IN (${dbIDs})`;
     cleanUpPromises.push(dbQuery(query));
   }
   const [deliveryResults] = await Promise.all([
     Promise.all(deliveryPromises),
     Promise.all(cleanUpPromises),
   ]);
 
   await saveNotifResults(deliveryResults, notifications, true);
 }
 
 // The results in deliveryResults will be combined with the rows
 // in rowsToSave and then written to the notifications table
 async function saveNotifResults(
   deliveryResults: $ReadOnlyArray<IOSResult | AndroidResult>,
   inputRowsToSave: Map<string, NotificationRow>,
   rescindable: boolean,
 ) {
   const rowsToSave = new Map(inputRowsToSave);
 
   const allInvalidTokens = [];
   for (const deliveryResult of deliveryResults) {
     const { info, delivery, invalidTokens } = deliveryResult;
     const { dbID, userID } = info;
     const curNotifRow = rowsToSave.get(dbID);
     if (curNotifRow) {
       curNotifRow.deliveries.push(delivery);
     } else {
       // Ternary expressions for Flow
       const threadID = info.threadID ? info.threadID : null;
       const messageID = info.messageID ? info.messageID : null;
       const collapseKey = info.collapseKey ? info.collapseKey : null;
       rowsToSave.set(dbID, {
         dbID,
         userID,
         threadID,
         messageID,
         collapseKey,
         deliveries: [delivery],
       });
     }
     if (invalidTokens) {
       allInvalidTokens.push({
         userID,
         tokens: invalidTokens,
       });
     }
   }
 
   const notificationRows = [];
   for (const notification of rowsToSave.values()) {
     notificationRows.push([
       notification.dbID,
       notification.userID,
       notification.threadID,
       notification.messageID,
       notification.collapseKey,
       JSON.stringify(notification.deliveries),
       Number(!rescindable),
     ]);
   }
 
   const dbPromises = [];
   if (allInvalidTokens.length > 0) {
     dbPromises.push(removeInvalidTokens(allInvalidTokens));
   }
   if (notificationRows.length > 0) {
     const query = SQL`
       INSERT INTO notifications
         (id, user, thread, message, collapse_key, delivery, rescinded)
       VALUES ${notificationRows}
     `;
     dbPromises.push(dbQuery(query));
   }
   if (dbPromises.length > 0) {
     await Promise.all(dbPromises);
   }
 }
 
 async function fetchInfos(pushInfo: PushInfo) {
   const usersToCollapsableNotifInfo = await fetchCollapsableNotifs(pushInfo);
 
   const threadIDs = new Set();
   const threadWithChangedNamesToMessages = new Map();
   const addThreadIDsFromMessageInfos = (rawMessageInfo: RawMessageInfo) => {
     const threadID = rawMessageInfo.threadID;
     threadIDs.add(threadID);
     const messageSpec = messageSpecs[rawMessageInfo.type];
     if (messageSpec.threadIDs) {
       for (const id of messageSpec.threadIDs(rawMessageInfo)) {
         threadIDs.add(id);
       }
     }
     if (
       rawMessageInfo.type === messageTypes.CHANGE_SETTINGS &&
       rawMessageInfo.field === 'name'
     ) {
       const messages = threadWithChangedNamesToMessages.get(threadID);
       if (messages) {
         messages.push(rawMessageInfo.id);
       } else {
         threadWithChangedNamesToMessages.set(threadID, [rawMessageInfo.id]);
       }
     }
   };
   for (const userID in usersToCollapsableNotifInfo) {
     for (const notifInfo of usersToCollapsableNotifInfo[userID]) {
       for (const rawMessageInfo of notifInfo.existingMessageInfos) {
         addThreadIDsFromMessageInfos(rawMessageInfo);
       }
       for (const rawMessageInfo of notifInfo.newMessageInfos) {
         addThreadIDsFromMessageInfos(rawMessageInfo);
       }
     }
   }
 
   const promises = {};
   // These threadInfos won't have currentUser set
   promises.threadResult = fetchServerThreadInfos(
     SQL`t.id IN (${[...threadIDs]})`,
   );
   if (threadWithChangedNamesToMessages.size > 0) {
     const typesThatAffectName = [
       messageTypes.CHANGE_SETTINGS,
       messageTypes.CREATE_THREAD,
     ];
     const oldNameQuery = SQL`
       SELECT IF(
         JSON_TYPE(JSON_EXTRACT(m.content, "$.name")) = 'NULL',
         "",
         JSON_UNQUOTE(JSON_EXTRACT(m.content, "$.name"))
       ) AS name, m.thread
       FROM (
         SELECT MAX(id) AS id
         FROM messages
         WHERE type IN (${typesThatAffectName})
           AND JSON_EXTRACT(content, "$.name") IS NOT NULL
           AND`;
     const threadClauses = [];
     for (const [threadID, messages] of threadWithChangedNamesToMessages) {
       threadClauses.push(
         SQL`(thread = ${threadID} AND id NOT IN (${messages}))`,
       );
     }
     oldNameQuery.append(mergeOrConditions(threadClauses));
     oldNameQuery.append(SQL`
         GROUP BY thread
       ) x
       LEFT JOIN messages m ON m.id = x.id
     `);
     promises.oldNames = dbQuery(oldNameQuery);
   }
 
   const { threadResult, oldNames } = await promiseAll(promises);
   const serverThreadInfos = threadResult.threadInfos;
   if (oldNames) {
     const [result] = oldNames;
     for (const row of result) {
       const threadID = row.thread.toString();
       serverThreadInfos[threadID].name = row.name;
     }
   }
 
   const userInfos = await fetchNotifUserInfos(
     serverThreadInfos,
     usersToCollapsableNotifInfo,
   );
 
   return { usersToCollapsableNotifInfo, serverThreadInfos, userInfos };
 }
 
 async function fetchNotifUserInfos(
   serverThreadInfos: { +[threadID: string]: ServerThreadInfo },
   usersToCollapsableNotifInfo: { +[userID: string]: CollapsableNotifInfo[] },
 ) {
   const missingUserIDs = new Set();
 
   for (const threadID in serverThreadInfos) {
     const serverThreadInfo = serverThreadInfos[threadID];
     for (const member of serverThreadInfo.members) {
       missingUserIDs.add(member.id);
     }
   }
 
   const addUserIDsFromMessageInfos = (rawMessageInfo: RawMessageInfo) => {
     missingUserIDs.add(rawMessageInfo.creatorID);
     const userIDs =
       messageSpecs[rawMessageInfo.type].userIDs?.(rawMessageInfo) ?? [];
     for (const userID of userIDs) {
       missingUserIDs.add(userID);
     }
   };
 
   for (const userID in usersToCollapsableNotifInfo) {
     for (const notifInfo of usersToCollapsableNotifInfo[userID]) {
       for (const rawMessageInfo of notifInfo.existingMessageInfos) {
         addUserIDsFromMessageInfos(rawMessageInfo);
       }
       for (const rawMessageInfo of notifInfo.newMessageInfos) {
         addUserIDsFromMessageInfos(rawMessageInfo);
       }
     }
   }
 
   return await fetchUserInfos([...missingUserIDs]);
 }
 
 async function createDBIDs(pushInfo: PushInfo): Promise<string[]> {
   let numIDsNeeded = 0;
   for (const userID in pushInfo) {
     numIDsNeeded += pushInfo[userID].messageInfos.length;
   }
   return await createIDs('notifications', numIDsNeeded);
 }
 
 function getDevicesByDeviceType(
   devices: Device[],
 ): Map<DeviceType, Map<number, Set<string>>> {
   const byDeviceType = new Map();
   for (const device of devices) {
     let innerMap = byDeviceType.get(device.deviceType);
     if (!innerMap) {
       innerMap = new Map();
       byDeviceType.set(device.deviceType, innerMap);
     }
     const codeVersion: number =
       device.codeVersion !== null && device.codeVersion !== undefined
         ? device.codeVersion
         : -1;
     let innerMostSet = innerMap.get(codeVersion);
     if (!innerMostSet) {
       innerMostSet = new Set();
       innerMap.set(codeVersion, innerMostSet);
     }
     innerMostSet.add(device.deviceToken);
   }
   return byDeviceType;
 }
 
 function prepareIOSNotification(
   allMessageInfos: MessageInfo[],
   newRawMessageInfos: RawMessageInfo[],
   threadInfo: ThreadInfo,
   collapseKey: ?string,
   badgeOnly: boolean,
   unreadCount: number,
   codeVersion: number,
 ): apn.Notification {
   const uniqueID = uuidv4();
   const notification = new apn.Notification();
   notification.topic = getAPNsNotificationTopic(codeVersion);
 
   const { merged, ...rest } = notifTextsForMessageInfo(
     allMessageInfos,
     threadInfo,
   );
   if (!badgeOnly) {
     notification.body = merged;
     notification.sound = 'default';
   }
   notification.payload = {
     ...notification.payload,
     ...rest,
   };
 
   notification.badge = unreadCount;
   notification.threadId = threadInfo.id;
   notification.id = uniqueID;
   notification.pushType = 'alert';
   notification.payload.id = uniqueID;
   notification.payload.threadID = threadInfo.id;
   if (codeVersion > 1000) {
     notification.mutableContent = true;
   }
   if (collapseKey) {
     notification.collapseId = collapseKey;
   }
   const messageInfos = JSON.stringify(newRawMessageInfos);
   const copyWithMessageInfos = _cloneDeep(notification);
   copyWithMessageInfos.payload = {
     ...copyWithMessageInfos.payload,
     messageInfos,
   };
   if (copyWithMessageInfos.length() <= apnMaxNotificationPayloadByteSize) {
     notification.payload.messageInfos = messageInfos;
   }
   return notification;
 }
 
 function prepareAndroidNotification(
   allMessageInfos: MessageInfo[],
   newRawMessageInfos: RawMessageInfo[],
   threadInfo: ThreadInfo,
   collapseKey: ?string,
   badgeOnly: boolean,
   unreadCount: number,
   dbID: string,
   codeVersion: number,
 ): Object {
   const notifID = collapseKey ? collapseKey : dbID;
   const { merged, ...rest } = notifTextsForMessageInfo(
     allMessageInfos,
     threadInfo,
   );
   const messageInfos = JSON.stringify(newRawMessageInfos);
 
   if (badgeOnly && codeVersion < 69) {
     // Older Android clients don't look at badgeOnly, so if we sent them the
     // full payload they would treat it as a normal notif. Instead we will
     // send them this payload that is missing an ID, which will prevent the
     // system notif from being generated, but still allow for in-app notifs
     // and badge updating.
     return {
       data: {
         badge: unreadCount.toString(),
         ...rest,
         threadID: threadInfo.id,
         messageInfos,
       },
     };
   } else if (codeVersion < 31) {
     return {
       data: {
         badge: unreadCount.toString(),
         custom_notification: JSON.stringify({
           channel: 'default',
           body: merged,
           badgeCount: unreadCount,
           id: notifID,
           priority: 'high',
           sound: 'default',
           icon: 'notif_icon',
           threadID: threadInfo.id,
           messageInfos,
           click_action: 'fcm.ACTION.HELLO',
         }),
       },
     };
   }
 
   return {
     data: {
       badge: unreadCount.toString(),
       ...rest,
       id: notifID,
       threadID: threadInfo.id,
       messageInfos,
       badgeOnly: badgeOnly ? '1' : '0',
     },
   };
 }
 
 type NotificationInfo =
   | {
       +source: 'new_message',
       +dbID: string,
       +userID: string,
       +threadID: string,
       +messageID: string,
       +collapseKey: ?string,
       +codeVersion: number,
     }
   | {
       +source: 'mark_as_unread' | 'mark_as_read' | 'activity_update',
       +dbID: string,
       +userID: string,
       +codeVersion: number,
     };
 
 type IOSDelivery = {
   source: $PropertyType<NotificationInfo, 'source'>,
   deviceType: 'ios',
   iosID: string,
   deviceTokens: $ReadOnlyArray<string>,
   codeVersion: number,
   errors?: $ReadOnlyArray<ResponseFailure>,
 };
 type IOSResult = {
   info: NotificationInfo,
   delivery: IOSDelivery,
   invalidTokens?: $ReadOnlyArray<string>,
 };
 async function sendIOSNotification(
   notification: apn.Notification,
   deviceTokens: $ReadOnlyArray<string>,
   notificationInfo: NotificationInfo,
 ): Promise<IOSResult> {
   const { source, codeVersion } = notificationInfo;
   const response = await apnPush({ notification, deviceTokens, codeVersion });
   const delivery: IOSDelivery = {
     source,
     deviceType: 'ios',
     iosID: notification.id,
     deviceTokens,
     codeVersion,
   };
   if (response.errors) {
     delivery.errors = response.errors;
   }
   const result: IOSResult = {
     info: notificationInfo,
     delivery,
   };
   if (response.invalidTokens) {
     result.invalidTokens = response.invalidTokens;
   }
   return result;
 }
 
 type AndroidDelivery = {
   source: $PropertyType<NotificationInfo, 'source'>,
   deviceType: 'android',
   androidIDs: $ReadOnlyArray<string>,
   deviceTokens: $ReadOnlyArray<string>,
   codeVersion: number,
   errors?: $ReadOnlyArray<Object>,
 };
 type AndroidResult = {
   info: NotificationInfo,
   delivery: AndroidDelivery,
   invalidTokens?: $ReadOnlyArray<string>,
 };
 async function sendAndroidNotification(
   notification: Object,
   deviceTokens: $ReadOnlyArray<string>,
   notificationInfo: NotificationInfo,
 ): Promise<AndroidResult> {
   const collapseKey = notificationInfo.collapseKey
     ? notificationInfo.collapseKey
     : null; // for Flow...
   const { source, codeVersion } = notificationInfo;
   const response = await fcmPush({
     notification,
     deviceTokens,
     collapseKey,
     codeVersion,
   });
   const androidIDs = response.fcmIDs ? response.fcmIDs : [];
   const delivery: AndroidDelivery = {
     source,
     deviceType: 'android',
     androidIDs,
     deviceTokens,
     codeVersion,
   };
   if (response.errors) {
     delivery.errors = response.errors;
   }
   const result: AndroidResult = {
     info: notificationInfo,
     delivery,
   };
   if (response.invalidTokens) {
     result.invalidTokens = response.invalidTokens;
   }
   return result;
 }
 
 type InvalidToken = {
   +userID: string,
   +tokens: $ReadOnlyArray<string>,
 };
 async function removeInvalidTokens(
   invalidTokens: $ReadOnlyArray<InvalidToken>,
 ): Promise<void> {
   const sqlTuples = invalidTokens.map(
     invalidTokenUser =>
       SQL`(
       user = ${invalidTokenUser.userID} AND
       device_token IN (${invalidTokenUser.tokens})
     )`,
   );
   const sqlCondition = mergeOrConditions(sqlTuples);
 
   const selectQuery = SQL`
     SELECT id, user, device_token
     FROM cookies
     WHERE
   `;
   selectQuery.append(sqlCondition);
   const [result] = await dbQuery(selectQuery);
 
   const userCookiePairsToInvalidDeviceTokens = new Map();
   for (const row of result) {
     const userCookiePair = `${row.user}|${row.id}`;
     const existing = userCookiePairsToInvalidDeviceTokens.get(userCookiePair);
     if (existing) {
       existing.add(row.device_token);
     } else {
       userCookiePairsToInvalidDeviceTokens.set(
         userCookiePair,
         new Set([row.device_token]),
       );
     }
   }
 
   const time = Date.now();
   const promises = [];
   for (const entry of userCookiePairsToInvalidDeviceTokens) {
     const [userCookiePair, deviceTokens] = entry;
     const [userID, cookieID] = userCookiePair.split('|');
     const updateDatas = [...deviceTokens].map(deviceToken => ({
       type: updateTypes.BAD_DEVICE_TOKEN,
       userID,
       time,
       deviceToken,
       targetCookie: cookieID,
     }));
     promises.push(createUpdates(updateDatas));
   }
 
   const updateQuery = SQL`
     UPDATE cookies
     SET device_token = NULL
     WHERE
   `;
   updateQuery.append(sqlCondition);
   promises.push(dbQuery(updateQuery));
 
   await Promise.all(promises);
 }
 
 async function updateBadgeCount(
   viewer: Viewer,
   source: 'mark_as_unread' | 'mark_as_read' | 'activity_update',
   excludeDeviceTokens: $ReadOnlyArray<string>,
 ) {
   const { userID } = viewer;
 
   const deviceTokenQuery = SQL`
     SELECT platform, device_token, versions
     FROM cookies
     WHERE user = ${userID}
       AND device_token IS NOT NULL
   `;
   if (viewer.data.cookieID) {
     deviceTokenQuery.append(SQL`AND id != ${viewer.cookieID} `);
   }
   if (excludeDeviceTokens.length > 0) {
     deviceTokenQuery.append(
       SQL`AND device_token NOT IN (${excludeDeviceTokens}) `,
     );
   }
-  const [
-    unreadCounts,
-    [deviceTokenResult],
-    [dbID],
-    dbType,
-  ] = await Promise.all([
+  const [unreadCounts, [deviceTokenResult], [dbID]] = await Promise.all([
     getUnreadCounts([userID]),
     dbQuery(deviceTokenQuery),
     createIDs('notifications', 1),
-    getDBType(),
   ]);
   const unreadCount = unreadCounts[userID];
 
   const devices = deviceTokenResult.map(row => ({
     deviceType: row.platform,
     deviceToken: row.device_token,
-    codeVersion:
-      dbType === 'mysql5.7'
-        ? row.versions?.codeVersion
-        : JSON.parse(row.versions)?.codeVersion,
+    codeVersion: JSON.parse(row.versions)?.codeVersion,
   }));
   const byDeviceType = getDevicesByDeviceType(devices);
 
   const deliveryPromises = [];
 
   const iosVersionsToTokens = byDeviceType.get('ios');
   if (iosVersionsToTokens) {
     for (const [codeVer, deviceTokens] of iosVersionsToTokens) {
       const codeVersion = parseInt(codeVer, 10); // only for Flow
       const notification = new apn.Notification();
       notification.topic = getAPNsNotificationTopic(codeVersion);
       notification.badge = unreadCount;
       notification.pushType = 'alert';
       deliveryPromises.push(
         sendIOSNotification(notification, [...deviceTokens], {
           source,
           dbID,
           userID,
           codeVersion,
         }),
       );
     }
   }
 
   const androidVersionsToTokens = byDeviceType.get('android');
   if (androidVersionsToTokens) {
     for (const [codeVer, deviceTokens] of androidVersionsToTokens) {
       const codeVersion = parseInt(codeVer, 10); // only for Flow
       const notificationData =
         codeVersion < 69
           ? { badge: unreadCount.toString() }
           : { badge: unreadCount.toString(), badgeOnly: '1' };
       const notification = { data: notificationData };
       deliveryPromises.push(
         sendAndroidNotification(notification, [...deviceTokens], {
           source,
           dbID,
           userID,
           codeVersion,
         }),
       );
     }
   }
 
   const deliveryResults = await Promise.all(deliveryPromises);
   await saveNotifResults(deliveryResults, new Map(), false);
 }
 
 export { sendPushNotifs, updateBadgeCount };
diff --git a/keyserver/src/session/cookies.js b/keyserver/src/session/cookies.js
index a17f52b4e..26c50f511 100644
--- a/keyserver/src/session/cookies.js
+++ b/keyserver/src/session/cookies.js
@@ -1,845 +1,835 @@
 // @flow
 
 import crypto from 'crypto';
 import type { $Response, $Request } from 'express';
 import invariant from 'invariant';
 import bcrypt from 'twin-bcrypt';
 import url from 'url';
 
 import { hasMinCodeVersion } from 'lib/shared/version-utils';
 import type { Shape } from 'lib/types/core';
 import type { Platform, PlatformDetails } from 'lib/types/device-types';
 import type { CalendarQuery } from 'lib/types/entry-types';
 import {
   type ServerSessionChange,
   cookieLifetime,
   cookieSources,
   type CookieSource,
   cookieTypes,
   sessionIdentifierTypes,
   type SessionIdentifierType,
 } from 'lib/types/session-types';
 import type { InitialClientSocketMessage } from 'lib/types/socket-types';
 import type { UserInfo } from 'lib/types/user-types';
 import { values } from 'lib/utils/objects';
 import { promiseAll } from 'lib/utils/promises';
 
 import createIDs from '../creators/id-creator';
 import { createSession } from '../creators/session-creator';
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 import { deleteCookie } from '../deleters/cookie-deleters';
 import { handleAsyncPromise } from '../responders/handlers';
 import { clearDeviceToken } from '../updaters/device-token-updaters';
 import { updateThreadMembers } from '../updaters/thread-updaters';
 import { assertSecureRequest } from '../utils/security-utils';
 import { type AppURLFacts, getAppURLFactsFromRequestURL } from '../utils/urls';
 import { Viewer } from './viewer';
 import type { AnonymousViewerData, UserViewerData } from './viewer';
 
 function cookieIsExpired(lastUsed: number) {
   return lastUsed + cookieLifetime <= Date.now();
 }
 
 type SessionParameterInfo = {
   isSocket: boolean,
   sessionID: ?string,
   sessionIdentifierType: SessionIdentifierType,
   ipAddress: string,
   userAgent: ?string,
 };
 
 type FetchViewerResult =
   | { type: 'valid', viewer: Viewer }
   | InvalidFetchViewerResult;
 
 type InvalidFetchViewerResult =
   | {
       type: 'nonexistant',
       cookieName: ?string,
       cookieSource: ?CookieSource,
       sessionParameterInfo: SessionParameterInfo,
     }
   | {
       type: 'invalidated',
       cookieName: string,
       cookieID: string,
       cookieSource: CookieSource,
       sessionParameterInfo: SessionParameterInfo,
       platformDetails: ?PlatformDetails,
       deviceToken: ?string,
     };
 
 async function fetchUserViewer(
   cookie: string,
   cookieSource: CookieSource,
   sessionParameterInfo: SessionParameterInfo,
 ): Promise<FetchViewerResult> {
   const [cookieID, cookiePassword] = cookie.split(':');
   if (!cookieID || !cookiePassword) {
     return {
       type: 'nonexistant',
       cookieName: cookieTypes.USER,
       cookieSource,
       sessionParameterInfo,
     };
   }
 
   const query = SQL`
     SELECT hash, user, last_used, platform, device_token, versions
     FROM cookies
     WHERE id = ${cookieID} AND user IS NOT NULL
   `;
-  const [[result], dbType, allSessionInfo] = await Promise.all([
+  const [[result], allSessionInfo] = await Promise.all([
     dbQuery(query),
-    getDBType(),
     fetchSessionInfo(sessionParameterInfo, cookieID),
   ]);
   if (result.length === 0) {
     return {
       type: 'nonexistant',
       cookieName: cookieTypes.USER,
       cookieSource,
       sessionParameterInfo,
     };
   }
 
   let sessionID = null,
     sessionInfo = null;
   if (allSessionInfo) {
     ({ sessionID, ...sessionInfo } = allSessionInfo);
   }
 
   const cookieRow = result[0];
   let platformDetails = null;
   if (cookieRow.versions) {
-    const versions =
-      dbType === 'mysql5.7'
-        ? cookieRow.versions
-        : JSON.parse(cookieRow.versions);
+    const versions = JSON.parse(cookieRow.versions);
     platformDetails = {
       platform: cookieRow.platform,
       codeVersion: versions.codeVersion,
       stateVersion: versions.stateVersion,
     };
   } else {
     platformDetails = { platform: cookieRow.platform };
   }
   const deviceToken = cookieRow.device_token;
 
   if (
     !bcrypt.compareSync(cookiePassword, cookieRow.hash) ||
     cookieIsExpired(cookieRow.last_used)
   ) {
     return {
       type: 'invalidated',
       cookieName: cookieTypes.USER,
       cookieID,
       cookieSource,
       sessionParameterInfo,
       platformDetails,
       deviceToken,
     };
   }
   const userID = cookieRow.user.toString();
   const viewer = new Viewer({
     isSocket: sessionParameterInfo.isSocket,
     loggedIn: true,
     id: userID,
     platformDetails,
     deviceToken,
     userID,
     cookieSource,
     cookieID,
     cookiePassword,
     sessionIdentifierType: sessionParameterInfo.sessionIdentifierType,
     sessionID,
     sessionInfo,
     isScriptViewer: false,
     ipAddress: sessionParameterInfo.ipAddress,
     userAgent: sessionParameterInfo.userAgent,
   });
   return { type: 'valid', viewer };
 }
 
 async function fetchAnonymousViewer(
   cookie: string,
   cookieSource: CookieSource,
   sessionParameterInfo: SessionParameterInfo,
 ): Promise<FetchViewerResult> {
   const [cookieID, cookiePassword] = cookie.split(':');
   if (!cookieID || !cookiePassword) {
     return {
       type: 'nonexistant',
       cookieName: cookieTypes.ANONYMOUS,
       cookieSource,
       sessionParameterInfo,
     };
   }
 
   const query = SQL`
     SELECT last_used, hash, platform, device_token, versions
     FROM cookies
     WHERE id = ${cookieID} AND user IS NULL
   `;
-  const [[result], dbType, allSessionInfo] = await Promise.all([
+  const [[result], allSessionInfo] = await Promise.all([
     dbQuery(query),
-    getDBType(),
     fetchSessionInfo(sessionParameterInfo, cookieID),
   ]);
   if (result.length === 0) {
     return {
       type: 'nonexistant',
       cookieName: cookieTypes.ANONYMOUS,
       cookieSource,
       sessionParameterInfo,
     };
   }
 
   let sessionID = null,
     sessionInfo = null;
   if (allSessionInfo) {
     ({ sessionID, ...sessionInfo } = allSessionInfo);
   }
 
   const cookieRow = result[0];
   let platformDetails = null;
   if (cookieRow.platform && cookieRow.versions) {
-    const versions =
-      dbType === 'mysql5.7'
-        ? cookieRow.versions
-        : JSON.parse(cookieRow.versions);
+    const versions = JSON.parse(cookieRow.versions);
     platformDetails = {
       platform: cookieRow.platform,
       codeVersion: versions.codeVersion,
       stateVersion: versions.stateVersion,
     };
   } else if (cookieRow.platform) {
     platformDetails = { platform: cookieRow.platform };
   }
   const deviceToken = cookieRow.device_token;
 
   if (
     !bcrypt.compareSync(cookiePassword, cookieRow.hash) ||
     cookieIsExpired(cookieRow.last_used)
   ) {
     return {
       type: 'invalidated',
       cookieName: cookieTypes.ANONYMOUS,
       cookieID,
       cookieSource,
       sessionParameterInfo,
       platformDetails,
       deviceToken,
     };
   }
   const viewer = new Viewer({
     isSocket: sessionParameterInfo.isSocket,
     loggedIn: false,
     id: cookieID,
     platformDetails,
     deviceToken,
     cookieSource,
     cookieID,
     cookiePassword,
     sessionIdentifierType: sessionParameterInfo.sessionIdentifierType,
     sessionID,
     sessionInfo,
     isScriptViewer: false,
     ipAddress: sessionParameterInfo.ipAddress,
     userAgent: sessionParameterInfo.userAgent,
   });
   return { type: 'valid', viewer };
 }
 
 type SessionInfo = {
   +sessionID: ?string,
   +lastValidated: number,
   +lastUpdate: number,
   +calendarQuery: CalendarQuery,
 };
 async function fetchSessionInfo(
   sessionParameterInfo: SessionParameterInfo,
   cookieID: string,
 ): Promise<?SessionInfo> {
   const { sessionID } = sessionParameterInfo;
   const session = sessionID !== undefined ? sessionID : cookieID;
   if (!session) {
     return null;
   }
   const query = SQL`
     SELECT query, last_validated, last_update
     FROM sessions
     WHERE id = ${session} AND cookie = ${cookieID}
   `;
-  const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+  const [result] = await dbQuery(query);
   if (result.length === 0) {
     return null;
   }
   return {
     sessionID,
     lastValidated: result[0].last_validated,
     lastUpdate: result[0].last_update,
-    calendarQuery:
-      dbType === 'mysql5.7' ? result[0].query : JSON.parse(result[0].query),
+    calendarQuery: JSON.parse(result[0].query),
   };
 }
 
 // This function is meant to consume a cookie that has already been processed.
 // That means it doesn't have any logic to handle an invalid cookie, and it
 // doesn't update the cookie's last_used timestamp.
 async function fetchViewerFromCookieData(
   req: $Request,
   sessionParameterInfo: SessionParameterInfo,
 ): Promise<FetchViewerResult> {
   let viewerResult;
   const { user, anonymous } = req.cookies;
   if (user) {
     viewerResult = await fetchUserViewer(
       user,
       cookieSources.HEADER,
       sessionParameterInfo,
     );
   } else if (anonymous) {
     viewerResult = await fetchAnonymousViewer(
       anonymous,
       cookieSources.HEADER,
       sessionParameterInfo,
     );
   } else {
     return {
       type: 'nonexistant',
       cookieName: null,
       cookieSource: null,
       sessionParameterInfo,
     };
   }
 
   // We protect against CSRF attacks by making sure that on web,
   // non-GET requests cannot use a bare cookie for session identification
   if (viewerResult.type === 'valid') {
     const { viewer } = viewerResult;
     invariant(
       req.method === 'GET' ||
         viewer.sessionIdentifierType !== sessionIdentifierTypes.COOKIE_ID ||
         viewer.platform !== 'web',
       'non-GET request from web using sessionIdentifierTypes.COOKIE_ID',
     );
   }
 
   return viewerResult;
 }
 
 async function fetchViewerFromRequestBody(
   body: mixed,
   sessionParameterInfo: SessionParameterInfo,
 ): Promise<FetchViewerResult> {
   if (!body || typeof body !== 'object') {
     return {
       type: 'nonexistant',
       cookieName: null,
       cookieSource: null,
       sessionParameterInfo,
     };
   }
   const cookiePair = body.cookie;
   if (cookiePair === null || cookiePair === '') {
     return {
       type: 'nonexistant',
       cookieName: null,
       cookieSource: cookieSources.BODY,
       sessionParameterInfo,
     };
   }
   if (!cookiePair || typeof cookiePair !== 'string') {
     return {
       type: 'nonexistant',
       cookieName: null,
       cookieSource: null,
       sessionParameterInfo,
     };
   }
   const [type, cookie] = cookiePair.split('=');
   if (type === cookieTypes.USER && cookie) {
     return await fetchUserViewer(
       cookie,
       cookieSources.BODY,
       sessionParameterInfo,
     );
   } else if (type === cookieTypes.ANONYMOUS && cookie) {
     return await fetchAnonymousViewer(
       cookie,
       cookieSources.BODY,
       sessionParameterInfo,
     );
   }
   return {
     type: 'nonexistant',
     cookieName: null,
     cookieSource: null,
     sessionParameterInfo,
   };
 }
 
 function getRequestIPAddress(req: $Request) {
   const { proxy } = getAppURLFactsFromRequestURL(req.originalUrl);
   let ipAddress;
   if (proxy === 'none') {
     ipAddress = req.socket.remoteAddress;
   } else if (proxy === 'apache') {
     ipAddress = req.get('X-Forwarded-For');
   }
   invariant(ipAddress, 'could not determine requesting IP address');
   return ipAddress;
 }
 
 function getSessionParameterInfoFromRequestBody(
   req: $Request,
 ): SessionParameterInfo {
   const body = (req.body: any);
   let sessionID =
     body.sessionID !== undefined || req.method !== 'GET'
       ? body.sessionID
       : null;
   if (sessionID === '') {
     sessionID = null;
   }
   const sessionIdentifierType =
     req.method === 'GET' || sessionID !== undefined
       ? sessionIdentifierTypes.BODY_SESSION_ID
       : sessionIdentifierTypes.COOKIE_ID;
   return {
     isSocket: false,
     sessionID,
     sessionIdentifierType,
     ipAddress: getRequestIPAddress(req),
     userAgent: req.get('User-Agent'),
   };
 }
 
 async function fetchViewerForJSONRequest(req: $Request): Promise<Viewer> {
   assertSecureRequest(req);
   const sessionParameterInfo = getSessionParameterInfoFromRequestBody(req);
   let result = await fetchViewerFromRequestBody(req.body, sessionParameterInfo);
   if (
     result.type === 'nonexistant' &&
     (result.cookieSource === null || result.cookieSource === undefined)
   ) {
     result = await fetchViewerFromCookieData(req, sessionParameterInfo);
   }
   return await handleFetchViewerResult(result);
 }
 
 const webPlatformDetails = { platform: 'web' };
 async function fetchViewerForHomeRequest(req: $Request): Promise<Viewer> {
   assertSecureRequest(req);
   const sessionParameterInfo = getSessionParameterInfoFromRequestBody(req);
   const result = await fetchViewerFromCookieData(req, sessionParameterInfo);
   return await handleFetchViewerResult(result, webPlatformDetails);
 }
 
 async function fetchViewerForSocket(
   req: $Request,
   clientMessage: InitialClientSocketMessage,
 ): Promise<?Viewer> {
   assertSecureRequest(req);
   const { sessionIdentification } = clientMessage.payload;
   const { sessionID } = sessionIdentification;
   const sessionParameterInfo = {
     isSocket: true,
     sessionID,
     sessionIdentifierType:
       sessionID !== undefined
         ? sessionIdentifierTypes.BODY_SESSION_ID
         : sessionIdentifierTypes.COOKIE_ID,
     ipAddress: getRequestIPAddress(req),
     userAgent: req.get('User-Agent'),
   };
 
   let result = await fetchViewerFromRequestBody(
     clientMessage.payload.sessionIdentification,
     sessionParameterInfo,
   );
   if (
     result.type === 'nonexistant' &&
     (result.cookieSource === null || result.cookieSource === undefined)
   ) {
     result = await fetchViewerFromCookieData(req, sessionParameterInfo);
   }
   if (result.type === 'valid') {
     return result.viewer;
   }
 
   const promises = {};
   if (result.cookieSource === cookieSources.BODY) {
     // We initialize a socket's Viewer after the WebSocket handshake, since to
     // properly initialize the Viewer we need a bunch of data, but that data
     // can't be sent until after the handshake. Consequently, by the time we
     // know that a cookie may be invalid, we are no longer communicating via
     // HTTP, and have no way to set a new cookie for HEADER (web) clients.
     const platformDetails =
       result.type === 'invalidated' ? result.platformDetails : null;
     const deviceToken =
       result.type === 'invalidated' ? result.deviceToken : null;
     promises.anonymousViewerData = createNewAnonymousCookie({
       platformDetails,
       deviceToken,
     });
   }
   if (result.type === 'invalidated') {
     promises.deleteCookie = deleteCookie(result.cookieID);
   }
   const { anonymousViewerData } = await promiseAll(promises);
 
   if (!anonymousViewerData) {
     return null;
   }
 
   return createViewerForInvalidFetchViewerResult(result, anonymousViewerData);
 }
 
 async function handleFetchViewerResult(
   result: FetchViewerResult,
   inputPlatformDetails?: PlatformDetails,
 ) {
   if (result.type === 'valid') {
     return result.viewer;
   }
 
   let platformDetails = inputPlatformDetails;
   if (!platformDetails && result.type === 'invalidated') {
     platformDetails = result.platformDetails;
   }
   const deviceToken = result.type === 'invalidated' ? result.deviceToken : null;
 
   const [anonymousViewerData] = await Promise.all([
     createNewAnonymousCookie({ platformDetails, deviceToken }),
     result.type === 'invalidated' ? deleteCookie(result.cookieID) : null,
   ]);
 
   return createViewerForInvalidFetchViewerResult(result, anonymousViewerData);
 }
 
 function createViewerForInvalidFetchViewerResult(
   result: InvalidFetchViewerResult,
   anonymousViewerData: AnonymousViewerData,
 ): Viewer {
   // If a null cookie was specified in the request body, result.cookieSource
   // will still be BODY here. The only way it would be null or undefined here
   // is if there was no cookie specified in either the body or the header, in
   // which case we default to returning the new cookie in the response header.
   const cookieSource =
     result.cookieSource !== null && result.cookieSource !== undefined
       ? result.cookieSource
       : cookieSources.HEADER;
   const viewer = new Viewer({
     ...anonymousViewerData,
     cookieSource,
     sessionIdentifierType: result.sessionParameterInfo.sessionIdentifierType,
     isSocket: result.sessionParameterInfo.isSocket,
     ipAddress: result.sessionParameterInfo.ipAddress,
     userAgent: result.sessionParameterInfo.userAgent,
   });
   viewer.sessionChanged = true;
 
   // If cookieName is falsey, that tells us that there was no cookie specified
   // in the request, which means we can't be invalidating anything.
   if (result.cookieName) {
     viewer.cookieInvalidated = true;
     viewer.initialCookieName = result.cookieName;
   }
 
   return viewer;
 }
 
 function addSessionChangeInfoToResult(
   viewer: Viewer,
   res: $Response,
   result: Object,
   appURLFacts: AppURLFacts,
 ) {
   let threadInfos = {},
     userInfos = {};
   if (result.cookieChange) {
     ({ threadInfos, userInfos } = result.cookieChange);
   }
   let sessionChange;
   if (viewer.cookieInvalidated) {
     sessionChange = ({
       cookieInvalidated: true,
       threadInfos,
       userInfos: (values(userInfos).map(a => a): UserInfo[]),
       currentUserInfo: {
         id: viewer.cookieID,
         anonymous: true,
       },
     }: ServerSessionChange);
   } else {
     sessionChange = ({
       cookieInvalidated: false,
       threadInfos,
       userInfos: (values(userInfos).map(a => a): UserInfo[]),
     }: ServerSessionChange);
   }
   if (viewer.cookieSource === cookieSources.BODY) {
     sessionChange.cookie = viewer.cookiePairString;
   } else {
     addActualHTTPCookie(viewer, res, appURLFacts);
   }
   if (viewer.sessionIdentifierType === sessionIdentifierTypes.BODY_SESSION_ID) {
     sessionChange.sessionID = viewer.sessionID ? viewer.sessionID : null;
   }
   result.cookieChange = sessionChange;
 }
 
 type AnonymousCookieCreationParams = Shape<{
   +platformDetails: ?PlatformDetails,
   +deviceToken: ?string,
 }>;
 const defaultPlatformDetails = {};
 
 // The result of this function should not be passed directly to the Viewer
 // constructor. Instead, it should be passed to viewer.setNewCookie. There are
 // several fields on AnonymousViewerData that are not set by this function:
 // sessionIdentifierType, cookieSource, ipAddress, and userAgent. These
 // parameters all depend on the initial request. If the result of this function
 // is passed to the Viewer constructor directly, the resultant Viewer object
 // will throw whenever anybody attempts to access the relevant properties.
 async function createNewAnonymousCookie(
   params: AnonymousCookieCreationParams,
 ): Promise<AnonymousViewerData> {
   const { platformDetails, deviceToken } = params;
   const { platform, ...versions } = platformDetails || defaultPlatformDetails;
   const versionsString =
     Object.keys(versions).length > 0 ? JSON.stringify(versions) : null;
 
   const time = Date.now();
   const cookiePassword = crypto.randomBytes(32).toString('hex');
   const cookieHash = bcrypt.hashSync(cookiePassword);
   const [[id]] = await Promise.all([
     createIDs('cookies', 1),
     deviceToken ? clearDeviceToken(deviceToken) : undefined,
   ]);
 
   const cookieRow = [
     id,
     cookieHash,
     null,
     platform,
     time,
     time,
     deviceToken,
     versionsString,
   ];
   const query = SQL`
     INSERT INTO cookies(id, hash, user, platform, creation_time, last_used,
       device_token, versions)
     VALUES ${[cookieRow]}
   `;
   await dbQuery(query);
   return {
     loggedIn: false,
     id,
     platformDetails,
     deviceToken,
     cookieID: id,
     cookiePassword,
     sessionID: undefined,
     sessionInfo: null,
     cookieInsertedThisRequest: true,
     isScriptViewer: false,
   };
 }
 
 type UserCookieCreationParams = {
   platformDetails: PlatformDetails,
   deviceToken?: ?string,
 };
 
 // The result of this function should never be passed directly to the Viewer
 // constructor. Instead, it should be passed to viewer.setNewCookie. There are
 // several fields on UserViewerData that are not set by this function:
 // sessionID, sessionIdentifierType, cookieSource, and ipAddress. These
 // parameters all depend on the initial request. If the result of this function
 // is passed to the Viewer constructor directly, the resultant Viewer object
 // will throw whenever anybody attempts to access the relevant properties.
 async function createNewUserCookie(
   userID: string,
   params: UserCookieCreationParams,
 ): Promise<UserViewerData> {
   const { platformDetails, deviceToken } = params;
   const { platform, ...versions } = platformDetails || defaultPlatformDetails;
   const versionsString =
     Object.keys(versions).length > 0 ? JSON.stringify(versions) : null;
 
   const time = Date.now();
   const cookiePassword = crypto.randomBytes(32).toString('hex');
   const cookieHash = bcrypt.hashSync(cookiePassword);
   const [[cookieID]] = await Promise.all([
     createIDs('cookies', 1),
     deviceToken ? clearDeviceToken(deviceToken) : undefined,
   ]);
 
   const cookieRow = [
     cookieID,
     cookieHash,
     userID,
     platform,
     time,
     time,
     deviceToken,
     versionsString,
   ];
   const query = SQL`
     INSERT INTO cookies(id, hash, user, platform, creation_time, last_used,
       device_token, versions)
     VALUES ${[cookieRow]}
   `;
   await dbQuery(query);
   return {
     loggedIn: true,
     id: userID,
     platformDetails,
     deviceToken,
     userID,
     cookieID,
     sessionID: undefined,
     sessionInfo: null,
     cookiePassword,
     cookieInsertedThisRequest: true,
     isScriptViewer: false,
   };
 }
 
 // This gets called after createNewUserCookie and from websiteResponder. If the
 // Viewer's sessionIdentifierType is COOKIE_ID then the cookieID is used as the
 // session identifier; otherwise, a new ID is created for the session.
 async function setNewSession(
   viewer: Viewer,
   calendarQuery: CalendarQuery,
   initialLastUpdate: number,
 ): Promise<void> {
   if (viewer.sessionIdentifierType !== sessionIdentifierTypes.COOKIE_ID) {
     const [sessionID] = await createIDs('sessions', 1);
     viewer.setSessionID(sessionID);
   }
   await createSession(viewer, calendarQuery, initialLastUpdate);
 }
 
 async function extendCookieLifespan(cookieID: string) {
   const time = Date.now();
   const query = SQL`
     UPDATE cookies SET last_used = ${time} WHERE id = ${cookieID}
   `;
   await dbQuery(query);
 }
 
 function addCookieToJSONResponse(
   viewer: Viewer,
   res: $Response,
   result: Object,
   expectCookieInvalidation: boolean,
   appURLFacts: AppURLFacts,
 ) {
   if (expectCookieInvalidation) {
     viewer.cookieInvalidated = false;
   }
   if (!viewer.getData().cookieInsertedThisRequest) {
     handleAsyncPromise(extendCookieLifespan(viewer.cookieID));
   }
   if (viewer.sessionChanged) {
     addSessionChangeInfoToResult(viewer, res, result, appURLFacts);
   } else if (viewer.cookieSource !== cookieSources.BODY) {
     addActualHTTPCookie(viewer, res, appURLFacts);
   }
 }
 
 function addCookieToHomeResponse(
   viewer: Viewer,
   res: $Response,
   appURLFacts: AppURLFacts,
 ) {
   if (!viewer.getData().cookieInsertedThisRequest) {
     handleAsyncPromise(extendCookieLifespan(viewer.cookieID));
   }
   addActualHTTPCookie(viewer, res, appURLFacts);
 }
 
 function getCookieOptions(appURLFacts: AppURLFacts) {
   const { baseDomain, basePath, https } = appURLFacts;
   const domainAsURL = new url.URL(baseDomain);
   return {
     domain: domainAsURL.hostname,
     path: basePath,
     httpOnly: true,
     secure: https,
     maxAge: cookieLifetime,
     sameSite: 'Strict',
   };
 }
 
 function addActualHTTPCookie(
   viewer: Viewer,
   res: $Response,
   appURLFacts: AppURLFacts,
 ) {
   res.cookie(
     viewer.cookieName,
     viewer.cookieString,
     getCookieOptions(appURLFacts),
   );
   if (viewer.cookieName !== viewer.initialCookieName) {
     res.clearCookie(viewer.initialCookieName, getCookieOptions(appURLFacts));
   }
 }
 
 async function setCookiePlatform(
   viewer: Viewer,
   platform: Platform,
 ): Promise<void> {
   const newPlatformDetails = { ...viewer.platformDetails, platform };
   viewer.setPlatformDetails(newPlatformDetails);
   const query = SQL`
     UPDATE cookies
     SET platform = ${platform}
     WHERE id = ${viewer.cookieID}
   `;
   await dbQuery(query);
 }
 
 async function setCookiePlatformDetails(
   viewer: Viewer,
   platformDetails: PlatformDetails,
 ): Promise<void> {
   if (
     hasMinCodeVersion(platformDetails, 70) &&
     !hasMinCodeVersion(viewer.platformDetails, 70)
   ) {
     await updateThreadMembers(viewer);
   }
 
   viewer.setPlatformDetails(platformDetails);
   const { platform, ...versions } = platformDetails;
   const versionsString =
     Object.keys(versions).length > 0 ? JSON.stringify(versions) : null;
   const query = SQL`
     UPDATE cookies
     SET platform = ${platform}, versions = ${versionsString}
     WHERE id = ${viewer.cookieID}
   `;
   await dbQuery(query);
 }
 
 export {
   fetchViewerForJSONRequest,
   fetchViewerForHomeRequest,
   fetchViewerForSocket,
   createNewAnonymousCookie,
   createNewUserCookie,
   setNewSession,
   extendCookieLifespan,
   addCookieToJSONResponse,
   addCookieToHomeResponse,
   setCookiePlatform,
   setCookiePlatformDetails,
 };
diff --git a/keyserver/src/updaters/account-updaters.js b/keyserver/src/updaters/account-updaters.js
index 08cdf5403..a9fce9533 100644
--- a/keyserver/src/updaters/account-updaters.js
+++ b/keyserver/src/updaters/account-updaters.js
@@ -1,122 +1,111 @@
 // @flow
 
 import bcrypt from 'twin-bcrypt';
 
 import type {
   ResetPasswordRequest,
   UpdatePasswordRequest,
   UpdateUserSettingsRequest,
   LogInResponse,
 } from 'lib/types/account-types';
 import { updateTypes } from 'lib/types/update-types';
 import type { PasswordUpdate } from 'lib/types/user-types';
 import { ServerError } from 'lib/utils/errors';
 
 import { createUpdates } from '../creators/update-creator';
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 import type { Viewer } from '../session/viewer';
 
 async function accountUpdater(
   viewer: Viewer,
   update: PasswordUpdate,
 ): Promise<void> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const newPassword = update.updatedFields.password;
   if (!newPassword) {
     // If it's an old client it may have given us an email,
     // but we don't store those anymore
     return;
   }
 
   const verifyQuery = SQL`
     SELECT username, hash FROM users WHERE id = ${viewer.userID}
   `;
   const [verifyResult] = await dbQuery(verifyQuery);
   if (verifyResult.length === 0) {
     throw new ServerError('internal_error');
   }
   const verifyRow = verifyResult[0];
   if (!bcrypt.compareSync(update.currentPassword, verifyRow.hash)) {
     throw new ServerError('invalid_credentials');
   }
 
   const changedFields = { hash: bcrypt.hashSync(newPassword) };
   const saveQuery = SQL`
     UPDATE users SET ${changedFields} WHERE id = ${viewer.userID}
   `;
   await dbQuery(saveQuery);
 
   const updateDatas = [
     {
       type: updateTypes.UPDATE_CURRENT_USER,
       userID: viewer.userID,
       time: Date.now(),
     },
   ];
   await createUpdates(updateDatas, {
     viewer,
     updatesForCurrentSession: 'broadcast',
   });
 }
 
 // eslint-disable-next-line no-unused-vars
 async function checkAndSendVerificationEmail(viewer: Viewer): Promise<void> {
   // We don't want to crash old clients that call this,
   // but we have nothing we can do because we no longer store email addresses
 }
 
 async function checkAndSendPasswordResetEmail(
   // eslint-disable-next-line no-unused-vars
   request: ResetPasswordRequest,
 ): Promise<void> {
   // We don't want to crash old clients that call this,
   // but we have nothing we can do because we no longer store email addresses
 }
 
 /* eslint-disable no-unused-vars */
 async function updatePassword(
   viewer: Viewer,
   request: UpdatePasswordRequest,
 ): Promise<LogInResponse> {
   /* eslint-enable no-unused-vars */
   // We have no way to handle this request anymore
   throw new ServerError('deprecated');
 }
 
 async function updateUserSettings(
   viewer: Viewer,
   request: UpdateUserSettingsRequest,
 ) {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const createOrUpdateSettingsQuery = SQL`
     INSERT INTO settings (user, name, data)
     VALUES ${[[viewer.id, request.name, request.data]]}
-  `;
-  const dbType = await getDBType();
-  if (dbType === 'mysql5.7') {
-    createOrUpdateSettingsQuery.append(SQL`
-    ON DUPLICATE KEY UPDATE data = VALUES(data)
-    `);
-  } else {
-    createOrUpdateSettingsQuery.append(SQL`
     ON DUPLICATE KEY UPDATE data = VALUE(data)
-    `);
-  }
-
+  `;
   await dbQuery(createOrUpdateSettingsQuery);
 }
 
 export {
   accountUpdater,
   checkAndSendVerificationEmail,
   checkAndSendPasswordResetEmail,
   updateUserSettings,
   updatePassword,
 };
diff --git a/keyserver/src/updaters/activity-updaters.js b/keyserver/src/updaters/activity-updaters.js
index 28dba54ab..dd422135e 100644
--- a/keyserver/src/updaters/activity-updaters.js
+++ b/keyserver/src/updaters/activity-updaters.js
@@ -1,528 +1,518 @@
 // @flow
 
 import invariant from 'invariant';
 import _difference from 'lodash/fp/difference';
 import _max from 'lodash/fp/max';
 
 import { localIDPrefix } from 'lib/shared/message-utils';
 import type {
   UpdateActivityResult,
   UpdateActivityRequest,
   SetThreadUnreadStatusRequest,
   SetThreadUnreadStatusResult,
 } from 'lib/types/activity-types';
 import { messageTypes } from 'lib/types/message-types';
 import { threadPermissions } from 'lib/types/thread-types';
 import { updateTypes } from 'lib/types/update-types';
 import { ServerError } from 'lib/utils/errors';
 
 import { createUpdates } from '../creators/update-creator';
 import { dbQuery, SQL, mergeOrConditions } from '../database/database';
-import { getDBType } from '../database/db-config';
 import type { SQLStatementType } from '../database/types';
 import { deleteActivityForViewerSession } from '../deleters/activity-deleters';
 import {
   checkThread,
   getValidThreads,
 } from '../fetchers/thread-permission-fetchers';
 import { rescindPushNotifs } from '../push/rescind';
 import { updateBadgeCount } from '../push/send';
 import type { Viewer } from '../session/viewer';
 import { earliestFocusedTimeConsideredExpired } from '../shared/focused-times';
 
 type PartialThreadStatus = {
   +focusActive: boolean,
   +threadID: string,
   +newLastReadMessage: ?number,
 };
 type ThreadStatus =
   | {
       +focusActive: true,
       +threadID: string,
       +newLastReadMessage: number,
       +curLastReadMessage: number,
       +rescindCondition: SQLStatementType,
     }
   | {
       +focusActive: false,
       +threadID: string,
       +newLastReadMessage: ?number,
       +curLastReadMessage: number,
       +rescindCondition: ?SQLStatementType,
       +newerMessageFromOtherAuthor: boolean,
     };
 async function activityUpdater(
   viewer: Viewer,
   request: UpdateActivityRequest,
 ): Promise<UpdateActivityResult> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const focusUpdatesByThreadID = new Map();
   for (const activityUpdate of request.updates) {
     const threadID = activityUpdate.threadID;
     const updatesForThreadID = focusUpdatesByThreadID.get(threadID) ?? [];
     if (!focusUpdatesByThreadID.has(threadID)) {
       focusUpdatesByThreadID.set(threadID, updatesForThreadID);
     }
     updatesForThreadID.push(activityUpdate);
   }
 
   const unverifiedThreadIDs: $ReadOnlySet<string> = new Set(
     request.updates.map(update => update.threadID),
   );
 
   const verifiedThreadsData = await getValidThreads(
     viewer,
     [...unverifiedThreadIDs],
     [
       {
         check: 'permission',
         permission: threadPermissions.VISIBLE,
       },
     ],
   );
 
   if (verifiedThreadsData.length === 0) {
     return { unfocusedToUnread: [] };
   }
 
   const memberThreadIDs = new Set();
   const verifiedThreadIDs = [];
   for (const threadData of verifiedThreadsData) {
     if (threadData.role > 0) {
       memberThreadIDs.add(threadData.threadID);
     }
     verifiedThreadIDs.push(threadData.threadID);
   }
 
   const partialThreadStatuses: PartialThreadStatus[] = [];
   for (const threadID of verifiedThreadIDs) {
     const focusUpdates = focusUpdatesByThreadID.get(threadID);
     invariant(focusUpdates, `no focusUpdate for thread ID ${threadID}`);
     const focusActive = !focusUpdates.some(update => !update.focus);
 
     const newLastReadMessage = _max(
       focusUpdates
         .filter(
           update =>
             update.latestMessage &&
             !update.latestMessage.startsWith(localIDPrefix),
         )
         .map(update => parseInt(update.latestMessage)),
     );
 
     partialThreadStatuses.push({
       threadID,
       focusActive,
       newLastReadMessage,
     });
   }
 
   // We update the focused rows before we check for new messages so we can
   // guarantee that any messages that may have set the thread to unread before
   // we set it to focused are caught and overriden
   await updateFocusedRows(viewer, partialThreadStatuses);
 
   if (memberThreadIDs.size === 0) {
     return { unfocusedToUnread: [] };
   }
 
   const memberPartialThreadStatuses = partialThreadStatuses.filter(
     partialStatus => memberThreadIDs.has(partialStatus.threadID),
   );
   const unfocusedLatestMessages = new Map<string, number>();
   for (const partialThreadStatus of memberPartialThreadStatuses) {
     const { threadID, focusActive, newLastReadMessage } = partialThreadStatus;
     if (!focusActive) {
       unfocusedLatestMessages.set(threadID, newLastReadMessage ?? 0);
     }
   }
   const [
     unfocusedThreadsWithNewerMessages,
     lastMessageInfos,
   ] = await Promise.all([
     checkForNewerMessages(viewer, unfocusedLatestMessages),
     fetchLastMessageInfo(viewer, [...memberThreadIDs]),
   ]);
 
   const threadStatuses: ThreadStatus[] = [];
   for (const partialThreadStatus of memberPartialThreadStatuses) {
     const { threadID, focusActive, newLastReadMessage } = partialThreadStatus;
 
     const lastMessageInfo = lastMessageInfos.get(threadID);
     invariant(
       lastMessageInfo !== undefined,
       `no lastMessageInfo for thread ID ${threadID}`,
     );
     const {
       lastMessage,
       lastReadMessage: curLastReadMessage,
     } = lastMessageInfo;
 
     if (focusActive) {
       threadStatuses.push({
         focusActive: true,
         threadID,
         newLastReadMessage: newLastReadMessage
           ? Math.max(lastMessage, newLastReadMessage)
           : lastMessage,
         curLastReadMessage,
         rescindCondition: SQL`n.thread = ${threadID}`,
       });
     } else {
       threadStatuses.push({
         focusActive: false,
         threadID,
         newLastReadMessage,
         curLastReadMessage,
         rescindCondition: newLastReadMessage
           ? SQL`(n.thread = ${threadID} AND n.message <= ${newLastReadMessage})`
           : null,
         newerMessageFromOtherAuthor: unfocusedThreadsWithNewerMessages.has(
           threadID,
         ),
       });
     }
   }
 
   // The following block determines whether to enqueue updates for a given
   // (user, thread) pair and whether to propagate badge count notifs to all of
   // that user's devices
   const setUnread: Array<{ +threadID: string, +unread: boolean }> = [];
   for (const threadStatus of threadStatuses) {
     const { threadID, curLastReadMessage } = threadStatus;
     if (!threadStatus.focusActive) {
       const { newLastReadMessage, newerMessageFromOtherAuthor } = threadStatus;
       if (newerMessageFromOtherAuthor) {
         setUnread.push({ threadID, unread: true });
       } else if (!newLastReadMessage) {
         // This is a rare edge case. It should only be possible for threads that
         // have zero messages on both the client and server, which shouldn't
         // happen. In this case we'll set the thread to read, just in case...
         console.warn(`thread ID ${threadID} appears to have no messages`);
         setUnread.push({ threadID, unread: false });
       } else if (newLastReadMessage > curLastReadMessage) {
         setUnread.push({ threadID, unread: false });
       }
     } else {
       const { newLastReadMessage } = threadStatus;
       if (newLastReadMessage > curLastReadMessage) {
         setUnread.push({ threadID, unread: false });
       }
     }
   }
 
   const time = Date.now();
   const updateDatas = setUnread.map(({ threadID, unread }) => ({
     type: updateTypes.UPDATE_THREAD_READ_STATUS,
     userID: viewer.userID,
     time,
     threadID,
     unread,
   }));
 
   const latestMessages = new Map<string, number>();
   for (const threadStatus of threadStatuses) {
     const { threadID, newLastReadMessage, curLastReadMessage } = threadStatus;
     if (newLastReadMessage && newLastReadMessage > curLastReadMessage) {
       latestMessages.set(threadID, newLastReadMessage);
     }
   }
   await Promise.all([
     updateLastReadMessage(viewer, latestMessages),
     createUpdates(updateDatas, { viewer, updatesForCurrentSession: 'ignore' }),
   ]);
 
   // We do this afterwards so the badge count is correct
   const rescindConditions = threadStatuses
     .map(({ rescindCondition }) => rescindCondition)
     .filter(Boolean);
   let rescindCondition;
   if (rescindConditions.length > 0) {
     rescindCondition = SQL`n.user = ${viewer.userID} AND `;
     rescindCondition.append(mergeOrConditions(rescindConditions));
   }
   await rescindAndUpdateBadgeCounts(
     viewer,
     rescindCondition,
     updateDatas.length > 0 ? 'activity_update' : null,
   );
 
   return { unfocusedToUnread: [...unfocusedThreadsWithNewerMessages] };
 }
 
 async function updateFocusedRows(
   viewer: Viewer,
   partialThreadStatuses: $ReadOnlyArray<PartialThreadStatus>,
 ): Promise<void> {
   const threadIDs = partialThreadStatuses
     .filter(threadStatus => threadStatus.focusActive)
     .map(({ threadID }) => threadID);
   const time = Date.now();
 
   if (threadIDs.length > 0) {
     const focusedInsertRows = threadIDs.map(threadID => [
       viewer.userID,
       viewer.session,
       threadID,
       time,
     ]);
     const query = SQL`
       INSERT INTO focused (user, session, thread, time)
       VALUES ${focusedInsertRows}
-    `;
-    const dbType = await getDBType();
-    if (dbType === 'mysql5.7') {
-      query.append(SQL`
-      ON DUPLICATE KEY UPDATE time = VALUES(time)
-      `);
-    } else {
-      query.append(SQL`
       ON DUPLICATE KEY UPDATE time = VALUE(time)
-      `);
-    }
+    `;
     await dbQuery(query);
   }
 
   if (viewer.hasSessionInfo) {
     await deleteActivityForViewerSession(viewer, time);
   }
 }
 
 // To protect against a possible race condition, we reset the thread to unread
 // if the latest message ID on the client at the time that focus was dropped
 // is no longer the latest message ID.
 // Returns the set of unfocused threads that should be set to unread on
 // the client because a new message arrived since they were unfocused.
 async function checkForNewerMessages(
   viewer: Viewer,
   latestMessages: Map<string, number>,
 ): Promise<Set<string>> {
   if (latestMessages.size === 0 || !viewer.loggedIn) {
     return new Set();
   }
 
   const unfocusedThreadIDs = [...latestMessages.keys()];
   const focusedElsewhereThreadIDs = await checkThreadsFocused(
     viewer,
     unfocusedThreadIDs,
   );
   const unreadCandidates = _difference(unfocusedThreadIDs)(
     focusedElsewhereThreadIDs,
   );
   if (unreadCandidates.length === 0) {
     return new Set();
   }
 
   const knowOfExtractString = `$.${threadPermissions.KNOW_OF}.value`;
   const query = SQL`
     SELECT m.thread, MAX(m.id) AS latest_message
     FROM messages m
     LEFT JOIN memberships stm ON m.type = ${messageTypes.CREATE_SUB_THREAD}
       AND stm.thread = m.content AND stm.user = ${viewer.userID}
     WHERE m.thread IN (${unreadCandidates}) AND
       m.user != ${viewer.userID} AND
       (
         m.type != ${messageTypes.CREATE_SUB_THREAD} OR
         JSON_EXTRACT(stm.permissions, ${knowOfExtractString}) IS TRUE
       )
     GROUP BY m.thread
   `;
   const [result] = await dbQuery(query);
 
   const threadsWithNewerMessages = new Set();
   for (const row of result) {
     const threadID = row.thread.toString();
     const serverLatestMessage = row.latest_message;
     const clientLatestMessage = latestMessages.get(threadID);
     if (clientLatestMessage < serverLatestMessage) {
       threadsWithNewerMessages.add(threadID);
     }
   }
   return threadsWithNewerMessages;
 }
 
 async function checkThreadsFocused(
   viewer: Viewer,
   threadIDs: $ReadOnlyArray<string>,
 ): Promise<string[]> {
   const time = earliestFocusedTimeConsideredExpired();
   const query = SQL`
     SELECT thread
     FROM focused
     WHERE time > ${time}
       AND user = ${viewer.userID}
       AND thread IN (${threadIDs})
     GROUP BY thread
   `;
   const [result] = await dbQuery(query);
 
   const focusedThreadIDs = [];
   for (const row of result) {
     focusedThreadIDs.push(row.thread.toString());
   }
   return focusedThreadIDs;
 }
 
 async function updateLastReadMessage(
   viewer: Viewer,
   lastReadMessages: $ReadOnlyMap<string, number>,
 ) {
   if (lastReadMessages.size === 0) {
     return;
   }
 
   const query = SQL`
     UPDATE memberships
     SET last_read_message = GREATEST(last_read_message, 
       CASE 
   `;
   lastReadMessages.forEach((lastMessage, threadID) => {
     query.append(SQL`
         WHEN thread = ${threadID} THEN ${lastMessage} `);
   });
   query.append(SQL`
         ELSE last_read_message
       END)
     WHERE thread IN (${[...lastReadMessages.keys()]}) 
       AND user = ${viewer.userID}
   `);
 
   return await dbQuery(query);
 }
 
 async function setThreadUnreadStatus(
   viewer: Viewer,
   request: SetThreadUnreadStatusRequest,
 ): Promise<SetThreadUnreadStatusResult> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const isMemberAndCanViewThread = await checkThread(viewer, request.threadID, [
     {
       check: 'is_member',
     },
     {
       check: 'permission',
       permission: threadPermissions.VISIBLE,
     },
   ]);
   if (!isMemberAndCanViewThread) {
     throw new ServerError('invalid_parameters');
   }
 
   const resetThreadToUnread = await shouldResetThreadToUnread(viewer, request);
   if (!resetThreadToUnread) {
     const lastReadMessage = request.unread
       ? SQL`0`
       : SQL`GREATEST(m.last_read_message, ${request.latestMessage ?? 0})`;
     const update = SQL`
       UPDATE memberships m
       SET m.last_read_message =
     `;
     update.append(lastReadMessage);
     update.append(SQL`
       WHERE m.thread = ${request.threadID} AND m.user = ${viewer.userID}
     `);
     const queryPromise = dbQuery(update);
 
     const time = Date.now();
     const updatesPromise = createUpdates(
       [
         {
           type: updateTypes.UPDATE_THREAD_READ_STATUS,
           userID: viewer.userID,
           time: time,
           threadID: request.threadID,
           unread: request.unread,
         },
       ],
       { viewer, updatesForCurrentSession: 'ignore' },
     );
 
     await Promise.all([updatesPromise, queryPromise]);
   }
 
   let rescindCondition;
   if (!request.unread) {
     rescindCondition = SQL`
       n.user = ${viewer.userID} AND
       n.thread = ${request.threadID} AND
       n.message <= ${request.latestMessage}
     `;
   }
   await rescindAndUpdateBadgeCounts(
     viewer,
     rescindCondition,
     request.unread ? 'mark_as_unread' : 'mark_as_read',
   );
 
   return {
     resetToUnread: resetThreadToUnread,
   };
 }
 
 async function rescindAndUpdateBadgeCounts(
   viewer: Viewer,
   rescindCondition: ?SQLStatementType,
   badgeCountUpdateSource: ?(
     | 'activity_update'
     | 'mark_as_unread'
     | 'mark_as_read'
   ),
 ) {
   const excludeDeviceTokens = [];
   if (rescindCondition) {
     const handledDeviceTokens = await rescindPushNotifs(rescindCondition);
     excludeDeviceTokens.push(...handledDeviceTokens);
   }
   if (badgeCountUpdateSource) {
     await updateBadgeCount(viewer, badgeCountUpdateSource, excludeDeviceTokens);
   }
 }
 
 async function shouldResetThreadToUnread(
   viewer: Viewer,
   request: SetThreadUnreadStatusRequest,
 ): Promise<boolean> {
   if (request.unread) {
     return false;
   }
 
   const threadsWithNewerMessages = await checkForNewerMessages(
     viewer,
     new Map([[request.threadID, parseInt(request.latestMessage) || 0]]),
   );
 
   return threadsWithNewerMessages.has(request.threadID);
 }
 
 type LastMessageInfo = {
   +lastMessage: number,
   +lastReadMessage: number,
 };
 async function fetchLastMessageInfo(
   viewer: Viewer,
   threadIDs: $ReadOnlyArray<string>,
 ) {
   const query = SQL`
     SELECT thread, last_message, last_read_message
     FROM memberships
     WHERE user = ${viewer.userID} AND thread IN (${threadIDs})
   `;
   const [result] = await dbQuery(query);
 
   const lastMessages = new Map<string, LastMessageInfo>();
   for (const row of result) {
     const threadID = row.thread.toString();
     const lastMessage = row.last_message;
     const lastReadMessage = row.last_read_message;
     lastMessages.set(threadID, { lastMessage, lastReadMessage });
   }
   return lastMessages;
 }
 
 export { activityUpdater, setThreadUnreadStatus };
diff --git a/keyserver/src/updaters/relationship-updaters.js b/keyserver/src/updaters/relationship-updaters.js
index 88342d59c..aa6a7bc69 100644
--- a/keyserver/src/updaters/relationship-updaters.js
+++ b/keyserver/src/updaters/relationship-updaters.js
@@ -1,413 +1,370 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { sortIDs } from 'lib/shared/relationship-utils';
 import { messageTypes } from 'lib/types/message-types';
 import {
   type RelationshipRequest,
   type RelationshipErrors,
   type UndirectedRelationshipRow,
   relationshipActions,
   undirectedStatus,
   directedStatus,
 } from 'lib/types/relationship-types';
 import { threadTypes } from 'lib/types/thread-types';
 import { updateTypes, type UpdateData } from 'lib/types/update-types';
 import { cartesianProduct } from 'lib/utils/array';
 import { ServerError } from 'lib/utils/errors';
 import { promiseAll } from 'lib/utils/promises';
 
 import createMessages from '../creators/message-creator';
 import { createThread } from '../creators/thread-creator';
 import { createUpdates } from '../creators/update-creator';
 import { dbQuery, SQL, mergeOrConditions } from '../database/database';
-import { getDBType } from '../database/db-config';
 import { fetchFriendRequestRelationshipOperations } from '../fetchers/relationship-fetchers';
 import { fetchUserInfos } from '../fetchers/user-fetchers';
 import type { Viewer } from '../session/viewer';
 
 async function updateRelationships(
   viewer: Viewer,
   request: RelationshipRequest,
 ): Promise<RelationshipErrors> {
   const { action } = request;
 
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const uniqueUserIDs = [...new Set(request.userIDs)];
-  const [users, dbType] = await Promise.all([
-    fetchUserInfos(uniqueUserIDs),
-    getDBType(),
-  ]);
+  const users = await fetchUserInfos(uniqueUserIDs);
 
   let errors = {};
   const userIDs: string[] = [];
   for (const userID of uniqueUserIDs) {
     if (userID === viewer.userID || !users[userID].username) {
       const acc = errors.invalid_user || [];
       errors.invalid_user = [...acc, userID];
     } else {
       userIDs.push(userID);
     }
   }
   if (!userIDs.length) {
     return Object.freeze({ ...errors });
   }
 
   const updateIDs = [];
   if (action === relationshipActions.FRIEND) {
     // We have to create personal threads before setting the relationship
     // status. By doing that we make sure that failed thread creation is
     // reported to the caller and can be repeated - there should be only
     // one PERSONAL thread per a pair of users and we can safely call it
     // repeatedly.
     const threadIDPerUser = await createPersonalThreads(viewer, request);
     const {
       userRelationshipOperations,
       errors: friendRequestErrors,
     } = await fetchFriendRequestRelationshipOperations(viewer, userIDs);
     errors = { ...errors, ...friendRequestErrors };
 
     const undirectedInsertRows = [];
     const directedInsertRows = [];
     const directedDeleteIDs = [];
     const messageDatas = [];
     const now = Date.now();
     for (const userID in userRelationshipOperations) {
       const operations = userRelationshipOperations[userID];
       const ids = sortIDs(viewer.userID, userID);
 
       if (operations.length) {
         updateIDs.push(userID);
       }
 
       for (const operation of operations) {
         if (operation === 'delete_directed') {
           directedDeleteIDs.push(userID);
         } else if (operation === 'friend') {
           const [user1, user2] = ids;
           const status = undirectedStatus.FRIEND;
           undirectedInsertRows.push({ user1, user2, status });
           messageDatas.push({
             type: messageTypes.UPDATE_RELATIONSHIP,
             threadID: threadIDPerUser[userID],
             creatorID: viewer.userID,
             targetID: userID,
             time: now,
             operation: 'request_accepted',
           });
         } else if (operation === 'pending_friend') {
           const status = directedStatus.PENDING_FRIEND;
           directedInsertRows.push([viewer.userID, userID, status]);
           messageDatas.push({
             type: messageTypes.UPDATE_RELATIONSHIP,
             threadID: threadIDPerUser[userID],
             creatorID: viewer.userID,
             targetID: userID,
             time: now,
             operation: 'request_sent',
           });
         } else if (operation === 'know_of') {
           const [user1, user2] = ids;
           const status = undirectedStatus.KNOW_OF;
           undirectedInsertRows.push({ user1, user2, status });
         } else {
           invariant(false, `unexpected relationship operation ${operation}`);
         }
       }
     }
 
     const promises = [updateUndirectedRelationships(undirectedInsertRows)];
     if (directedInsertRows.length) {
       const directedInsertQuery = SQL`
         INSERT INTO relationships_directed (user1, user2, status)
         VALUES ${directedInsertRows}
-      `;
-      if (dbType === 'mysql5.7') {
-        directedInsertQuery.append(SQL`
-        ON DUPLICATE KEY UPDATE status = VALUES(status)
-        `);
-      } else {
-        directedInsertQuery.append(SQL`
         ON DUPLICATE KEY UPDATE status = VALUE(status)
-        `);
-      }
+      `;
       promises.push(dbQuery(directedInsertQuery));
     }
     if (directedDeleteIDs.length) {
       const directedDeleteQuery = SQL`
         DELETE FROM relationships_directed
         WHERE 
           (user1 = ${viewer.userID} AND user2 IN (${directedDeleteIDs})) OR
           (status = ${directedStatus.PENDING_FRIEND} AND 
             user1 IN (${directedDeleteIDs}) AND user2 = ${viewer.userID})
       `;
       promises.push(dbQuery(directedDeleteQuery));
     }
     if (messageDatas.length > 0) {
       promises.push(createMessages(viewer, messageDatas, 'broadcast'));
     }
 
     await Promise.all(promises);
   } else if (action === relationshipActions.UNFRIEND) {
     updateIDs.push(...userIDs);
 
     const updateRows = userIDs.map(userID => {
       const [user1, user2] = sortIDs(viewer.userID, userID);
       return { user1, user2, status: undirectedStatus.KNOW_OF };
     });
 
     const deleteQuery = SQL`
       DELETE FROM relationships_directed
       WHERE 
         status = ${directedStatus.PENDING_FRIEND} AND 
         (user1 = ${viewer.userID} AND user2 IN (${userIDs}) OR 
           user1 IN (${userIDs}) AND user2 = ${viewer.userID})
     `;
 
     await Promise.all([
       updateUndirectedRelationships(updateRows, false),
       dbQuery(deleteQuery),
     ]);
   } else if (action === relationshipActions.BLOCK) {
     updateIDs.push(...userIDs);
 
     const directedRows = [];
     const undirectedRows = [];
     for (const userID of userIDs) {
       directedRows.push([viewer.userID, userID, directedStatus.BLOCKED]);
       const [user1, user2] = sortIDs(viewer.userID, userID);
       undirectedRows.push({ user1, user2, status: undirectedStatus.KNOW_OF });
     }
 
     const directedInsertQuery = SQL`
       INSERT INTO relationships_directed (user1, user2, status)
       VALUES ${directedRows}
-    `;
-    if (dbType === 'mysql5.7') {
-      directedInsertQuery.append(SQL`
-      ON DUPLICATE KEY UPDATE status = VALUES(status)
-      `);
-    } else {
-      directedInsertQuery.append(SQL`
       ON DUPLICATE KEY UPDATE status = VALUE(status)
-      `);
-    }
+    `;
     const directedDeleteQuery = SQL`
       DELETE FROM relationships_directed
       WHERE status = ${directedStatus.PENDING_FRIEND} AND 
         user1 IN (${userIDs}) AND user2 = ${viewer.userID}
     `;
 
     await Promise.all([
       dbQuery(directedInsertQuery),
       dbQuery(directedDeleteQuery),
       updateUndirectedRelationships(undirectedRows, false),
     ]);
   } else if (action === relationshipActions.UNBLOCK) {
     updateIDs.push(...userIDs);
 
     const query = SQL`
       DELETE FROM relationships_directed
       WHERE status = ${directedStatus.BLOCKED} AND 
         user1 = ${viewer.userID} AND user2 IN (${userIDs})
     `;
     await dbQuery(query);
   } else {
     invariant(false, `action ${action} is invalid or not supported currently`);
   }
 
   await createUpdates(
     updateDatasForUserPairs(cartesianProduct([viewer.userID], updateIDs)),
   );
 
   return Object.freeze({ ...errors });
 }
 
 function updateDatasForUserPairs(
   userPairs: $ReadOnlyArray<[string, string]>,
 ): UpdateData[] {
   const time = Date.now();
   const updateDatas = [];
   for (const [user1, user2] of userPairs) {
     updateDatas.push({
       type: updateTypes.UPDATE_USER,
       userID: user1,
       time,
       updatedUserID: user2,
     });
     updateDatas.push({
       type: updateTypes.UPDATE_USER,
       userID: user2,
       time,
       updatedUserID: user1,
     });
   }
   return updateDatas;
 }
 
 async function updateUndirectedRelationships(
   changeset: UndirectedRelationshipRow[],
   greatest: boolean = true,
 ) {
   if (!changeset.length) {
     return;
   }
 
   const rows = changeset.map(row => [row.user1, row.user2, row.status]);
   const query = SQL`
     INSERT INTO relationships_undirected (user1, user2, status)
     VALUES ${rows}
   `;
-
-  const dbType = await getDBType();
   if (greatest) {
-    if (dbType === 'mysql5.7') {
-      query.append(
-        SQL`ON DUPLICATE KEY UPDATE status = GREATEST(status, VALUES(status))`,
-      );
-    } else {
-      query.append(
-        SQL`ON DUPLICATE KEY UPDATE status = GREATEST(status, VALUE(status))`,
-      );
-    }
+    query.append(
+      SQL`ON DUPLICATE KEY UPDATE status = GREATEST(status, VALUE(status))`,
+    );
   } else {
-    if (dbType === 'mysql5.7') {
-      query.append(SQL`ON DUPLICATE KEY UPDATE status = VALUES(status)`);
-    } else {
-      query.append(SQL`ON DUPLICATE KEY UPDATE status = VALUE(status)`);
-    }
+    query.append(SQL`ON DUPLICATE KEY UPDATE status = VALUE(status)`);
   }
   await dbQuery(query);
 }
 
 async function updateChangedUndirectedRelationships(
   changeset: UndirectedRelationshipRow[],
 ): Promise<UpdateData[]> {
   if (changeset.length === 0) {
     return [];
   }
 
   const user2ByUser1: Map<string, Set<string>> = new Map();
   for (const { user1, user2 } of changeset) {
     if (!user2ByUser1.has(user1)) {
       user2ByUser1.set(user1, new Set());
     }
     user2ByUser1.get(user1)?.add(user2);
   }
 
   const selectQuery = SQL`
     SELECT user1, user2, status
     FROM relationships_undirected
     WHERE
   `;
   const conditions = [];
   for (const [user1, users] of user2ByUser1) {
     conditions.push(SQL`(user1 = ${user1} AND user2 IN (${[...users]}))`);
   }
   selectQuery.append(mergeOrConditions(conditions));
 
-  const [[result], dbType] = await Promise.all([
-    dbQuery(selectQuery),
-    getDBType(),
-  ]);
+  const [result] = await dbQuery(selectQuery);
   const existingStatuses = new Map();
   for (const row of result) {
     existingStatuses.set(`${row.user1}|${row.user2}`, row.status);
   }
 
   const insertRows = [];
   for (const row of changeset) {
     const existingStatus = existingStatuses.get(`${row.user1}|${row.user2}`);
     if (!existingStatus || existingStatus < row.status) {
       insertRows.push([row.user1, row.user2, row.status]);
     }
   }
   if (insertRows.length === 0) {
     return [];
   }
   const insertQuery = SQL`
     INSERT INTO relationships_undirected (user1, user2, status)
     VALUES ${insertRows}
-  `;
-  if (dbType === 'mysql5.7') {
-    insertQuery.append(SQL`
-    ON DUPLICATE KEY UPDATE status = GREATEST(status, VALUES(status))
-    `);
-  } else {
-    insertQuery.append(SQL`
     ON DUPLICATE KEY UPDATE status = GREATEST(status, VALUE(status))
-    `);
-  }
+  `;
   await dbQuery(insertQuery);
 
   return updateDatasForUserPairs(
     insertRows.map(([user1, user2]) => [user1, user2]),
   );
 }
 
 async function createPersonalThreads(
   viewer: Viewer,
   request: RelationshipRequest,
 ) {
   invariant(
     request.action === relationshipActions.FRIEND,
     'We should only create a PERSONAL threads when sending a FRIEND request, ' +
       `but we tried to do that for ${request.action}`,
   );
 
   const threadIDPerUser = {};
 
   const personalThreadsQuery = SQL`
     SELECT t.id AS threadID, m2.user AS user2
     FROM threads t
     INNER JOIN memberships m1
       ON m1.thread = t.id AND m1.user = ${viewer.userID}
     INNER JOIN memberships m2
       ON m2.thread = t.id AND m2.user IN (${request.userIDs})
     WHERE t.type = ${threadTypes.PERSONAL}
       AND m1.role > 0
       AND m2.role > 0
   `;
   const [personalThreadsResult] = await dbQuery(personalThreadsQuery);
 
   for (const row of personalThreadsResult) {
     const user2 = row.user2.toString();
     threadIDPerUser[user2] = row.threadID.toString();
   }
 
   const threadCreationPromises = {};
   for (const userID of request.userIDs) {
     if (threadIDPerUser[userID]) {
       continue;
     }
     threadCreationPromises[userID] = createThread(
       viewer,
       {
         type: threadTypes.PERSONAL,
         initialMemberIDs: [userID],
       },
       { forceAddMembers: true, updatesForCurrentSession: 'broadcast' },
     );
   }
 
   const personalThreadPerUser = await promiseAll(threadCreationPromises);
 
   for (const userID in personalThreadPerUser) {
     const newThread = personalThreadPerUser[userID];
     threadIDPerUser[userID] =
       newThread.newThreadID ?? newThread.newThreadInfo.id;
   }
 
   return threadIDPerUser;
 }
 
 export {
   updateRelationships,
   updateDatasForUserPairs,
   updateUndirectedRelationships,
   updateChangedUndirectedRelationships,
 };
diff --git a/keyserver/src/updaters/thread-permission-updaters.js b/keyserver/src/updaters/thread-permission-updaters.js
index cae2046a0..ec7638f42 100644
--- a/keyserver/src/updaters/thread-permission-updaters.js
+++ b/keyserver/src/updaters/thread-permission-updaters.js
@@ -1,1351 +1,1296 @@
 // @flow
 
 import invariant from 'invariant';
 import _isEqual from 'lodash/fp/isEqual';
 
 import bots from 'lib/facts/bots';
 import genesis from 'lib/facts/genesis';
 import {
   makePermissionsBlob,
   makePermissionsForChildrenBlob,
   getRoleForPermissions,
 } from 'lib/permissions/thread-permissions';
 import type { CalendarQuery } from 'lib/types/entry-types';
 import {
   type ThreadPermissionsBlob,
   type ThreadRolePermissionsBlob,
   type ThreadType,
   assertThreadType,
 } from 'lib/types/thread-types';
 import {
   updateTypes,
   type ServerUpdateInfo,
   type CreateUpdatesResult,
 } from 'lib/types/update-types';
 import { pushAll } from 'lib/utils/array';
 import { ServerError } from 'lib/utils/errors';
 
 import {
   createUpdates,
   type UpdatesForCurrentSession,
 } from '../creators/update-creator';
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 import {
   fetchServerThreadInfos,
   rawThreadInfosFromServerThreadInfos,
   type FetchThreadInfosResult,
 } from '../fetchers/thread-fetchers';
 import { rescindPushNotifs } from '../push/rescind';
 import { createScriptViewer } from '../session/scripts';
 import type { Viewer } from '../session/viewer';
 import { updateRoles } from '../updaters/role-updaters';
 import DepthQueue from '../utils/depth-queue';
 import RelationshipChangeset from '../utils/relationship-changeset';
 import { updateChangedUndirectedRelationships } from './relationship-updaters';
 
 export type MembershipRowToSave = {
   +operation: 'save',
   +intent: 'join' | 'leave' | 'none',
   +userID: string,
   +threadID: string,
   +userNeedsFullThreadDetails: boolean,
   +permissions: ?ThreadPermissionsBlob,
   +permissionsForChildren: ?ThreadPermissionsBlob,
   // null role represents by "0"
   +role: string,
   +oldRole: string,
   +unread?: boolean,
 };
 type MembershipRowToDelete = {
   +operation: 'delete',
   +intent: 'join' | 'leave' | 'none',
   +userID: string,
   +threadID: string,
   +oldRole: string,
 };
 type MembershipRow = MembershipRowToSave | MembershipRowToDelete;
 type Changeset = {
   +membershipRows: MembershipRow[],
   +relationshipChangeset: RelationshipChangeset,
 };
 
 // 0 role means to remove the user from the thread
 // null role means to set the user to the default role
 // string role means to set the user to the role with that ID
 // -1 role means to set the user as a "ghost" (former member)
 type ChangeRoleOptions = {
   +setNewMembersToUnread?: boolean,
 };
 type ChangeRoleMemberInfo = {
   permissionsFromParent?: ?ThreadPermissionsBlob,
   memberOfContainingThread?: boolean,
 };
 async function changeRole(
   threadID: string,
   userIDs: $ReadOnlyArray<string>,
   role: string | -1 | 0 | null,
   options?: ChangeRoleOptions,
 ): Promise<Changeset> {
   const intent = role === -1 || role === 0 ? 'leave' : 'join';
   const setNewMembersToUnread =
     options?.setNewMembersToUnread && intent === 'join';
 
   if (userIDs.length === 0) {
     return {
       membershipRows: [],
       relationshipChangeset: new RelationshipChangeset(),
     };
   }
 
   const membershipQuery = SQL`
     SELECT user, role, permissions, permissions_for_children
     FROM memberships
     WHERE thread = ${threadID}
   `;
   const parentMembershipQuery = SQL`
     SELECT pm.user, pm.permissions_for_children AS permissions_from_parent
     FROM threads t
     INNER JOIN memberships pm ON pm.thread = t.parent_thread_id
     WHERE t.id = ${threadID} AND
       (pm.user IN (${userIDs}) OR t.parent_thread_id != ${genesis.id})
   `;
   const containingMembershipQuery = SQL`
     SELECT cm.user, cm.role AS containing_role
     FROM threads t
     INNER JOIN memberships cm ON cm.thread = t.containing_thread_id
     WHERE t.id = ${threadID} AND cm.user IN (${userIDs})
   `;
   const [
-    dbType,
     [membershipResults],
     [parentMembershipResults],
     containingMembershipResults,
     roleThreadResult,
   ] = await Promise.all([
-    getDBType(),
     dbQuery(membershipQuery),
     dbQuery(parentMembershipQuery),
     (async () => {
       if (intent === 'leave') {
         // Membership in the container only needs to be checked for members
         return [];
       }
       const [result] = await dbQuery(containingMembershipQuery);
       return result;
     })(),
     changeRoleThreadQuery(threadID, role),
   ]);
 
   const {
     roleColumnValue: intendedRole,
     threadType,
     parentThreadID,
     hasContainingThreadID,
     rolePermissions: intendedRolePermissions,
     depth,
   } = roleThreadResult;
 
   const existingMembershipInfo = new Map();
   for (const row of membershipResults) {
     const userID = row.user.toString();
     existingMembershipInfo.set(userID, {
       oldRole: row.role.toString(),
-      oldPermissions:
-        dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions),
-      oldPermissionsForChildren:
-        dbType === 'mysql5.7'
-          ? row.permissions_for_children
-          : JSON.parse(row.permissions_for_children),
+      oldPermissions: JSON.parse(row.permissions),
+      oldPermissionsForChildren: JSON.parse(row.permissions_for_children),
     });
   }
 
   const ancestorMembershipInfo: Map<string, ChangeRoleMemberInfo> = new Map();
   for (const row of parentMembershipResults) {
     const userID = row.user.toString();
     if (!userIDs.includes(userID)) {
       continue;
     }
     ancestorMembershipInfo.set(userID, {
-      permissionsFromParent:
-        dbType === 'mysql5.7'
-          ? row.permissions_from_parent
-          : JSON.parse(row.permissions_from_parent),
+      permissionsFromParent: JSON.parse(row.permissions_from_parent),
     });
   }
   for (const row of containingMembershipResults) {
     const userID = row.user.toString();
     const ancestorMembership = ancestorMembershipInfo.get(userID);
     const memberOfContainingThread = row.containing_role > 0;
     if (ancestorMembership) {
       ancestorMembership.memberOfContainingThread = memberOfContainingThread;
     } else {
       ancestorMembershipInfo.set(userID, {
         memberOfContainingThread,
       });
     }
   }
 
   const relationshipChangeset = new RelationshipChangeset();
   const existingMemberIDs = [...existingMembershipInfo.keys()];
   if (threadID !== genesis.id) {
     relationshipChangeset.setAllRelationshipsExist(existingMemberIDs);
   }
   const parentMemberIDs = parentMembershipResults.map(row =>
     row.user.toString(),
   );
   if (parentThreadID && parentThreadID !== genesis.id) {
     relationshipChangeset.setAllRelationshipsExist(parentMemberIDs);
   }
 
   const membershipRows = [];
   const toUpdateDescendants = new Map();
   for (const userID of userIDs) {
     const existingMembership = existingMembershipInfo.get(userID);
     const oldRole = existingMembership?.oldRole ?? '-1';
     const oldPermissions = existingMembership?.oldPermissions ?? null;
     const oldPermissionsForChildren =
       existingMembership?.oldPermissionsForChildren ?? null;
 
     if (existingMembership && oldRole === intendedRole) {
       // If the old role is the same as the new one, we have nothing to update
       continue;
     } else if (Number(oldRole) > 0 && role === null) {
       // In the case where we're just trying to add somebody to a thread, if
       // they already have a role with a nonzero role then we don't need to do
       // anything
       continue;
     }
 
     let permissionsFromParent = null;
     let memberOfContainingThread = false;
     const ancestorMembership = ancestorMembershipInfo.get(userID);
     if (ancestorMembership) {
       permissionsFromParent = ancestorMembership.permissionsFromParent;
       memberOfContainingThread = ancestorMembership.memberOfContainingThread;
     }
     if (!hasContainingThreadID) {
       memberOfContainingThread = true;
     }
 
     const rolePermissions = memberOfContainingThread
       ? intendedRolePermissions
       : null;
     const targetRole = memberOfContainingThread ? intendedRole : '-1';
 
     const permissions = makePermissionsBlob(
       rolePermissions,
       permissionsFromParent,
       threadID,
       threadType,
     );
     const permissionsForChildren = makePermissionsForChildrenBlob(permissions);
     const newRole = getRoleForPermissions(targetRole, permissions);
     const userBecameMember = Number(oldRole) <= 0 && Number(newRole) > 0;
     const userLostMembership = Number(oldRole) > 0 && Number(newRole) <= 0;
 
     if (
       (intent === 'join' && Number(newRole) <= 0) ||
       (intent === 'leave' && Number(newRole) > 0)
     ) {
       throw new ServerError('invalid_parameters');
     } else if (intendedRole !== newRole) {
       console.warn(
         `changeRole called for role=${intendedRole}, but ended up setting ` +
           `role=${newRole} for userID ${userID} and threadID ${threadID}, ` +
           'probably because KNOW_OF permission was unexpectedly present or ' +
           'missing',
       );
     }
     if (
       existingMembership &&
       _isEqual(permissions)(oldPermissions) &&
       oldRole === newRole
     ) {
       // This thread and all of its descendants need no updates for this user,
       // since the corresponding memberships row is unchanged by this operation
       continue;
     }
 
     if (permissions) {
       membershipRows.push({
         operation: 'save',
         intent,
         userID,
         threadID,
         userNeedsFullThreadDetails: userBecameMember,
         permissions,
         permissionsForChildren,
         role: newRole,
         oldRole,
         unread: userBecameMember && setNewMembersToUnread,
       });
     } else {
       membershipRows.push({
         operation: 'delete',
         intent,
         userID,
         threadID,
         oldRole,
       });
     }
 
     if (permissions && !existingMembership && threadID !== genesis.id) {
       relationshipChangeset.setRelationshipsNeeded(userID, existingMemberIDs);
     }
 
     if (
       userLostMembership ||
       !_isEqual(permissionsForChildren)(oldPermissionsForChildren)
     ) {
       toUpdateDescendants.set(userID, {
         userIsMember: Number(newRole) > 0,
         permissionsForChildren,
       });
     }
   }
 
   if (toUpdateDescendants.size > 0) {
     const {
       membershipRows: descendantMembershipRows,
       relationshipChangeset: descendantRelationshipChangeset,
     } = await updateDescendantPermissions({
       threadID,
       depth,
       changesByUser: toUpdateDescendants,
     });
     pushAll(membershipRows, descendantMembershipRows);
     relationshipChangeset.addAll(descendantRelationshipChangeset);
   }
 
   return { membershipRows, relationshipChangeset };
 }
 
 type RoleThreadResult = {
   +roleColumnValue: string,
   +depth: number,
   +threadType: ThreadType,
   +parentThreadID: ?string,
   +hasContainingThreadID: boolean,
   +rolePermissions: ?ThreadRolePermissionsBlob,
 };
 async function changeRoleThreadQuery(
   threadID: string,
   role: string | -1 | 0 | null,
 ): Promise<RoleThreadResult> {
   if (role === 0 || role === -1) {
     const query = SQL`
       SELECT type, depth, parent_thread_id, containing_thread_id
       FROM threads
       WHERE id = ${threadID}
     `;
     const [result] = await dbQuery(query);
     if (result.length === 0) {
       throw new ServerError('internal_error');
     }
     const row = result[0];
     return {
       roleColumnValue: role.toString(),
       depth: row.depth,
       threadType: assertThreadType(row.type),
       parentThreadID: row.parent_thread_id
         ? row.parent_thread_id.toString()
         : null,
       hasContainingThreadID: row.containing_thread_id !== null,
       rolePermissions: null,
     };
   } else if (role !== null) {
     const query = SQL`
       SELECT t.type, t.depth, t.parent_thread_id, t.containing_thread_id,
         r.permissions
       FROM threads t
       INNER JOIN roles r ON r.thread = t.id AND r.id = ${role}
       WHERE t.id = ${threadID}
     `;
-    const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+    const [result] = await dbQuery(query);
     if (result.length === 0) {
       throw new ServerError('internal_error');
     }
     const row = result[0];
     return {
       roleColumnValue: role,
       depth: row.depth,
       threadType: assertThreadType(row.type),
       parentThreadID: row.parent_thread_id
         ? row.parent_thread_id.toString()
         : null,
       hasContainingThreadID: row.containing_thread_id !== null,
-      rolePermissions:
-        dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions),
+      rolePermissions: JSON.parse(row.permissions),
     };
   } else {
     const query = SQL`
       SELECT t.type, t.depth, t.parent_thread_id, t.containing_thread_id,
         t.default_role, r.permissions
       FROM threads t
       INNER JOIN roles r ON r.thread = t.id AND r.id = t.default_role
       WHERE t.id = ${threadID}
     `;
-    const [[result], dbType] = await Promise.all([dbQuery(query), getDBType()]);
+    const [result] = await dbQuery(query);
     if (result.length === 0) {
       throw new ServerError('internal_error');
     }
     const row = result[0];
     return {
       roleColumnValue: row.default_role.toString(),
       depth: row.depth,
       threadType: assertThreadType(row.type),
       parentThreadID: row.parent_thread_id
         ? row.parent_thread_id.toString()
         : null,
       hasContainingThreadID: row.containing_thread_id !== null,
-      rolePermissions:
-        dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions),
+      rolePermissions: JSON.parse(row.permissions),
     };
   }
 }
 
 type ChangedAncestor = {
   +threadID: string,
   +depth: number,
   +changesByUser: Map<string, AncestorChanges>,
 };
 type AncestorChanges = {
   +userIsMember: boolean,
   +permissionsForChildren: ?ThreadPermissionsBlob,
 };
 async function updateDescendantPermissions(
   initialChangedAncestor: ChangedAncestor,
 ): Promise<Changeset> {
   const membershipRows = [];
   const relationshipChangeset = new RelationshipChangeset();
 
   const initialDescendants = await fetchDescendantsForUpdate([
     initialChangedAncestor,
   ]);
 
   const depthQueue = new DepthQueue(
     getDescendantDepth,
     getDescendantKey,
     mergeDescendants,
   );
   depthQueue.addInfos(initialDescendants);
 
   let descendants;
   while ((descendants = depthQueue.getNextDepth())) {
     const descendantsAsAncestors = [];
     for (const descendant of descendants) {
       const { threadID, threadType, depth, users } = descendant;
 
       const existingMembers = [...users.entries()];
       const existingMemberIDs = existingMembers
         .filter(([, { curRole }]) => curRole)
         .map(([userID]) => userID);
       if (threadID !== genesis.id) {
         relationshipChangeset.setAllRelationshipsExist(existingMemberIDs);
       }
 
       const usersForNextLayer = new Map();
       for (const [userID, user] of users) {
         const {
           curRolePermissions,
           curPermissionsFromParent,
           curMemberOfContainingThread,
           nextMemberOfContainingThread,
           nextPermissionsFromParent,
           potentiallyNeedsUpdate,
         } = user;
         const existingMembership = !!user.curRole;
         const curRole = user.curRole ?? '-1';
         const curPermissions = user.curPermissions ?? null;
         const curPermissionsForChildren =
           user.curPermissionsForChildren ?? null;
 
         if (!potentiallyNeedsUpdate) {
           continue;
         }
 
         const permissionsFromParent =
           nextPermissionsFromParent === undefined
             ? curPermissionsFromParent
             : nextPermissionsFromParent;
         const memberOfContainingThread =
           nextMemberOfContainingThread === undefined
             ? curMemberOfContainingThread
             : nextMemberOfContainingThread;
         const targetRole = memberOfContainingThread ? curRole : '-1';
         const rolePermissions = memberOfContainingThread
           ? curRolePermissions
           : null;
 
         const permissions = makePermissionsBlob(
           rolePermissions,
           permissionsFromParent,
           threadID,
           threadType,
         );
         const permissionsForChildren = makePermissionsForChildrenBlob(
           permissions,
         );
         const newRole = getRoleForPermissions(targetRole, permissions);
         const userLostMembership = Number(curRole) > 0 && Number(newRole) <= 0;
 
         if (_isEqual(permissions)(curPermissions) && curRole === newRole) {
           // This thread and all of its descendants need no updates for this
           // user, since the corresponding memberships row is unchanged by this
           // operation
           continue;
         }
 
         if (permissions) {
           membershipRows.push({
             operation: 'save',
             intent: 'none',
             userID,
             threadID,
             userNeedsFullThreadDetails: false,
             permissions,
             permissionsForChildren,
             role: newRole,
             oldRole: curRole,
           });
         } else {
           membershipRows.push({
             operation: 'delete',
             intent: 'none',
             userID,
             threadID,
             oldRole: curRole,
           });
         }
 
         if (permissions && !existingMembership && threadID !== genesis.id) {
           // If there was no membership row before, and we are creating one,
           // we'll need to make sure the new member has a relationship row with
           // each existing member. We expect that whoever called us already
           // generated memberships row for the new members, will will lead
           // saveMemberships to generate relationships rows between those new
           // users.
           relationshipChangeset.setRelationshipsNeeded(
             userID,
             existingMemberIDs,
           );
         }
 
         if (
           userLostMembership ||
           !_isEqual(permissionsForChildren)(curPermissionsForChildren)
         ) {
           usersForNextLayer.set(userID, {
             userIsMember: Number(newRole) > 0,
             permissionsForChildren,
           });
         }
       }
       if (usersForNextLayer.size > 0) {
         descendantsAsAncestors.push({
           threadID,
           depth,
           changesByUser: usersForNextLayer,
         });
       }
     }
 
     const nextDescendants = await fetchDescendantsForUpdate(
       descendantsAsAncestors,
     );
     depthQueue.addInfos(nextDescendants);
   }
   return { membershipRows, relationshipChangeset };
 }
 
 type DescendantUserInfo = $Shape<{
   curRole?: string,
   curRolePermissions?: ?ThreadRolePermissionsBlob,
   curPermissions?: ?ThreadPermissionsBlob,
   curPermissionsForChildren?: ?ThreadPermissionsBlob,
   curPermissionsFromParent?: ?ThreadPermissionsBlob,
   curMemberOfContainingThread?: boolean,
   nextPermissionsFromParent?: ?ThreadPermissionsBlob,
   nextMemberOfContainingThread?: boolean,
   potentiallyNeedsUpdate?: boolean,
 }>;
 type DescendantInfo = {
   +threadID: string,
   +parentThreadID: string,
   +containingThreadID: string,
   +threadType: ThreadType,
   +depth: number,
   +users: Map<string, DescendantUserInfo>,
 };
 const fetchDescendantsBatchSize = 10;
 async function fetchDescendantsForUpdate(
   ancestors: $ReadOnlyArray<ChangedAncestor>,
 ): Promise<DescendantInfo[]> {
   const threadIDs = ancestors.map(ancestor => ancestor.threadID);
 
   const rows = [];
-  const queriesPromise = (async () => {
-    while (threadIDs.length > 0) {
-      const batch = threadIDs.splice(0, fetchDescendantsBatchSize);
-      const query = SQL`
-        SELECT t.id, m.user, t.type, t.depth, t.parent_thread_id,
-          t.containing_thread_id, r.permissions AS role_permissions, m.permissions,
-          m.permissions_for_children, m.role,
-          pm.permissions_for_children AS permissions_from_parent,
-          cm.role AS containing_role
-        FROM threads t
-        INNER JOIN memberships m ON m.thread = t.id
-        LEFT JOIN memberships pm
-          ON pm.thread = t.parent_thread_id AND pm.user = m.user
-        LEFT JOIN memberships cm
-          ON cm.thread = t.containing_thread_id AND cm.user = m.user
-        LEFT JOIN roles r ON r.id = m.role
-        WHERE t.parent_thread_id IN (${batch})
-          OR t.containing_thread_id IN (${batch})
-      `;
-      const [results] = await dbQuery(query);
-      pushAll(rows, results);
-    }
-  })();
-  const [dbType] = await Promise.all([getDBType(), queriesPromise]);
+  while (threadIDs.length > 0) {
+    const batch = threadIDs.splice(0, fetchDescendantsBatchSize);
+    const query = SQL`
+      SELECT t.id, m.user, t.type, t.depth, t.parent_thread_id,
+        t.containing_thread_id, r.permissions AS role_permissions, m.permissions,
+        m.permissions_for_children, m.role,
+        pm.permissions_for_children AS permissions_from_parent,
+        cm.role AS containing_role
+      FROM threads t
+      INNER JOIN memberships m ON m.thread = t.id
+      LEFT JOIN memberships pm
+        ON pm.thread = t.parent_thread_id AND pm.user = m.user
+      LEFT JOIN memberships cm
+        ON cm.thread = t.containing_thread_id AND cm.user = m.user
+      LEFT JOIN roles r ON r.id = m.role
+      WHERE t.parent_thread_id IN (${batch})
+        OR t.containing_thread_id IN (${batch})
+    `;
+    const [results] = await dbQuery(query);
+    pushAll(rows, results);
+  }
 
   const descendantThreadInfos: Map<string, DescendantInfo> = new Map();
   for (const row of rows) {
     const descendantThreadID = row.id.toString();
     if (!descendantThreadInfos.has(descendantThreadID)) {
       descendantThreadInfos.set(descendantThreadID, {
         threadID: descendantThreadID,
         parentThreadID: row.parent_thread_id.toString(),
         containingThreadID: row.containing_thread_id.toString(),
         threadType: assertThreadType(row.type),
         depth: row.depth,
         users: new Map(),
       });
     }
     const descendantThreadInfo = descendantThreadInfos.get(descendantThreadID);
     invariant(
       descendantThreadInfo,
       `value should exist for key ${descendantThreadID}`,
     );
     const userID = row.user.toString();
     descendantThreadInfo.users.set(userID, {
       curRole: row.role.toString(),
-      curRolePermissions:
-        dbType === 'mysql5.7'
-          ? row.role_permissions
-          : JSON.parse(row.role_permissions),
-      curPermissions:
-        dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions),
-      curPermissionsForChildren:
-        dbType === 'mysql5.7'
-          ? row.permissions_for_children
-          : JSON.parse(row.permissions_for_children),
-      curPermissionsFromParent:
-        dbType === 'mysql5.7'
-          ? row.permissions_from_parent
-          : JSON.parse(row.permissions_from_parent),
+      curRolePermissions: JSON.parse(row.role_permissions),
+      curPermissions: JSON.parse(row.permissions),
+      curPermissionsForChildren: JSON.parse(row.permissions_for_children),
+      curPermissionsFromParent: JSON.parse(row.permissions_from_parent),
       curMemberOfContainingThread: row.containing_role > 0,
     });
   }
 
   for (const ancestor of ancestors) {
     const { threadID, changesByUser } = ancestor;
     for (const [userID, changes] of changesByUser) {
       for (const descendantThreadInfo of descendantThreadInfos.values()) {
         const {
           users,
           parentThreadID,
           containingThreadID,
         } = descendantThreadInfo;
         if (threadID !== parentThreadID && threadID !== containingThreadID) {
           continue;
         }
         let user = users.get(userID);
         if (!user) {
           user = {};
           users.set(userID, user);
         }
         if (threadID === parentThreadID) {
           user.nextPermissionsFromParent = changes.permissionsForChildren;
           user.potentiallyNeedsUpdate = true;
         }
         if (threadID === containingThreadID) {
           user.nextMemberOfContainingThread = changes.userIsMember;
           if (!user.nextMemberOfContainingThread) {
             user.potentiallyNeedsUpdate = true;
           }
         }
       }
     }
   }
 
   return [...descendantThreadInfos.values()];
 }
 
 function getDescendantDepth(descendant: DescendantInfo): number {
   return descendant.depth;
 }
 function getDescendantKey(descendant: DescendantInfo): string {
   return descendant.threadID;
 }
 function mergeDescendants(
   a: DescendantInfo,
   b: DescendantInfo,
 ): DescendantInfo {
   const { users: usersA, ...restA } = a;
   const { users: usersB, ...restB } = b;
   if (!_isEqual(restA)(restB)) {
     console.warn(
       `inconsistent descendantInfos ${JSON.stringify(restA)}, ` +
         JSON.stringify(restB),
     );
     throw new ServerError('internal_error');
   }
 
   const newUsers = new Map(usersA);
   for (const [userID, userFromB] of usersB) {
     const userFromA = newUsers.get(userID);
     if (!userFromA) {
       newUsers.set(userID, userFromB);
     } else {
       newUsers.set(userID, { ...userFromA, ...userFromB });
     }
   }
 
   return { ...a, users: newUsers };
 }
 
 type RecalculatePermissionsMemberInfo = {
   role?: ?string,
   permissions?: ?ThreadPermissionsBlob,
   permissionsForChildren?: ?ThreadPermissionsBlob,
   rolePermissions?: ?ThreadRolePermissionsBlob,
   memberOfContainingThread?: boolean,
   permissionsFromParent?: ?ThreadPermissionsBlob,
 };
 async function recalculateThreadPermissions(
   threadID: string,
 ): Promise<Changeset> {
   const threadQuery = SQL`
     SELECT type, depth, parent_thread_id, containing_thread_id
     FROM threads
     WHERE id = ${threadID}
   `;
   const membershipQuery = SQL`
     SELECT m.user, m.role, m.permissions, m.permissions_for_children,
       r.permissions AS role_permissions, cm.role AS containing_role
     FROM threads t
     INNER JOIN memberships m ON m.thread = t.id
     LEFT JOIN roles r ON r.id = m.role
     LEFT JOIN memberships cm
       ON cm.user = m.user AND cm.thread = t.containing_thread_id
     WHERE t.id = ${threadID}
   `;
   const parentMembershipQuery = SQL`
     SELECT pm.user, pm.permissions_for_children AS permissions_from_parent
     FROM threads t
     INNER JOIN memberships pm ON pm.thread = t.parent_thread_id
     WHERE t.id = ${threadID}
   `;
   const [
-    dbType,
     [threadResults],
     [membershipResults],
     [parentMembershipResults],
   ] = await Promise.all([
-    getDBType(),
     dbQuery(threadQuery),
     dbQuery(membershipQuery),
     dbQuery(parentMembershipQuery),
   ]);
 
   if (threadResults.length !== 1) {
     throw new ServerError('internal_error');
   }
   const [threadResult] = threadResults;
   const threadType = assertThreadType(threadResult.type);
   const depth = threadResult.depth;
   const hasContainingThreadID = threadResult.containing_thread_id !== null;
   const parentThreadID = threadResult.parent_thread_id?.toString();
 
   const membershipInfo: Map<
     string,
     RecalculatePermissionsMemberInfo,
   > = new Map();
   for (const row of membershipResults) {
     const userID = row.user.toString();
     membershipInfo.set(userID, {
       role: row.role.toString(),
-      permissions:
-        dbType === 'mysql5.7' ? row.permissions : JSON.parse(row.permissions),
-      permissionsForChildren:
-        dbType === 'mysql5.7'
-          ? row.permissions_for_children
-          : JSON.parse(row.permissions_for_children),
-      rolePermissions:
-        dbType === 'mysql5.7'
-          ? row.role_permissions
-          : JSON.parse(row.role_permissions),
+      permissions: JSON.parse(row.permissions),
+      permissionsForChildren: JSON.parse(row.permissions_for_children),
+      rolePermissions: JSON.parse(row.role_permissions),
       memberOfContainingThread: !!(
         row.containing_role && row.containing_role > 0
       ),
     });
   }
   for (const row of parentMembershipResults) {
     const userID = row.user.toString();
-    const permissionsFromParent =
-      dbType === 'mysql5.7'
-        ? row.permissions_from_parent
-        : JSON.parse(row.permissions_from_parent);
+    const permissionsFromParent = JSON.parse(row.permissions_from_parent);
     const membership = membershipInfo.get(userID);
     if (membership) {
       membership.permissionsFromParent = permissionsFromParent;
     } else {
       membershipInfo.set(userID, {
         permissionsFromParent: permissionsFromParent,
       });
     }
   }
 
   const relationshipChangeset = new RelationshipChangeset();
   const existingMemberIDs = membershipResults.map(row => row.user.toString());
   if (threadID !== genesis.id) {
     relationshipChangeset.setAllRelationshipsExist(existingMemberIDs);
   }
   const parentMemberIDs = parentMembershipResults.map(row =>
     row.user.toString(),
   );
   if (parentThreadID && parentThreadID !== genesis.id) {
     relationshipChangeset.setAllRelationshipsExist(parentMemberIDs);
   }
 
   const membershipRows = [];
   const toUpdateDescendants = new Map();
   for (const [userID, membership] of membershipInfo) {
     const {
       rolePermissions: intendedRolePermissions,
       permissionsFromParent,
     } = membership;
     const oldPermissions = membership?.permissions ?? null;
     const oldPermissionsForChildren =
       membership?.permissionsForChildren ?? null;
 
     const existingMembership = membership.role !== undefined;
     const oldRole = membership.role ?? '-1';
     const memberOfContainingThread = hasContainingThreadID
       ? !!membership.memberOfContainingThread
       : true;
     const targetRole = memberOfContainingThread ? oldRole : '-1';
     const rolePermissions = memberOfContainingThread
       ? intendedRolePermissions
       : null;
 
     const permissions = makePermissionsBlob(
       rolePermissions,
       permissionsFromParent,
       threadID,
       threadType,
     );
     const permissionsForChildren = makePermissionsForChildrenBlob(permissions);
     const newRole = getRoleForPermissions(targetRole, permissions);
     const userLostMembership = Number(oldRole) > 0 && Number(newRole) <= 0;
 
     if (_isEqual(permissions)(oldPermissions) && oldRole === newRole) {
       // This thread and all of its descendants need no updates for this user,
       // since the corresponding memberships row is unchanged by this operation
       continue;
     }
 
     if (permissions) {
       membershipRows.push({
         operation: 'save',
         intent: 'none',
         userID,
         threadID,
         userNeedsFullThreadDetails: false,
         permissions,
         permissionsForChildren,
         role: newRole,
         oldRole,
       });
     } else {
       membershipRows.push({
         operation: 'delete',
         intent: 'none',
         userID,
         threadID,
         oldRole,
       });
     }
 
     if (permissions && !existingMembership && threadID !== genesis.id) {
       // If there was no membership row before, and we are creating one,
       // we'll need to make sure the new member has a relationship row with
       // each existing member. We handle guaranteeing that new members have
       // relationship rows with each other in saveMemberships.
       relationshipChangeset.setRelationshipsNeeded(userID, existingMemberIDs);
     }
 
     if (
       userLostMembership ||
       !_isEqual(permissionsForChildren)(oldPermissionsForChildren)
     ) {
       toUpdateDescendants.set(userID, {
         userIsMember: Number(newRole) > 0,
         permissionsForChildren,
       });
     }
   }
 
   if (toUpdateDescendants.size > 0) {
     const {
       membershipRows: descendantMembershipRows,
       relationshipChangeset: descendantRelationshipChangeset,
     } = await updateDescendantPermissions({
       threadID,
       depth,
       changesByUser: toUpdateDescendants,
     });
     pushAll(membershipRows, descendantMembershipRows);
     relationshipChangeset.addAll(descendantRelationshipChangeset);
   }
 
   return { membershipRows, relationshipChangeset };
 }
 
 const defaultSubscriptionString = JSON.stringify({
   home: false,
   pushNotifs: false,
 });
 const joinSubscriptionString = JSON.stringify({ home: true, pushNotifs: true });
 
 const membershipInsertBatchSize = 50;
 
 async function saveMemberships(toSave: $ReadOnlyArray<MembershipRowToSave>) {
   if (toSave.length === 0) {
     return;
   }
 
   const time = Date.now();
   const insertRows = [];
   for (const rowToSave of toSave) {
     insertRows.push([
       rowToSave.userID,
       rowToSave.threadID,
       rowToSave.role,
       time,
       rowToSave.intent === 'join'
         ? joinSubscriptionString
         : defaultSubscriptionString,
       rowToSave.permissions ? JSON.stringify(rowToSave.permissions) : null,
       rowToSave.permissionsForChildren
         ? JSON.stringify(rowToSave.permissionsForChildren)
         : null,
       rowToSave.unread ? 1 : 0,
       0,
     ]);
   }
 
   // Logic below will only update an existing membership row's `subscription`
   // column if the user is either joining or leaving the thread. That means
   // there's no way to use this function to update a user's subscription without
   // also making them join or leave the thread. The reason we do this is because
   // we need to specify a value for `subscription` here, as it's a non-null
   // column and this is an INSERT, but we don't want to require people to have
   // to know the current `subscription` when they're just using this function to
   // update the permissions of an existing membership row.
-  const dbType = await getDBType();
   while (insertRows.length > 0) {
     const batch = insertRows.splice(0, membershipInsertBatchSize);
     const query = SQL`
       INSERT INTO memberships (user, thread, role, creation_time, subscription,
         permissions, permissions_for_children, last_message, last_read_message)
       VALUES ${batch}
-    `;
-    if (dbType === 'mysql5.7') {
-      query.append(SQL`
-      ON DUPLICATE KEY UPDATE
-        subscription = IF(
-          (role <= 0 AND VALUES(role) > 0)
-            OR (role > 0 AND VALUES(role) <= 0),
-          VALUES(subscription),
-          subscription
-        ),
-        role = VALUES(role),
-        permissions = VALUES(permissions),
-        permissions_for_children = VALUES(permissions_for_children)
-      `);
-    } else {
-      query.append(SQL`
       ON DUPLICATE KEY UPDATE
         subscription = IF(
           (role <= 0 AND VALUE(role) > 0)
             OR (role > 0 AND VALUE(role) <= 0),
           VALUE(subscription),
           subscription
         ),
         role = VALUE(role),
         permissions = VALUE(permissions),
         permissions_for_children = VALUE(permissions_for_children)
-      `);
-    }
+    `;
     await dbQuery(query);
   }
 }
 
 async function deleteMemberships(
   toDelete: $ReadOnlyArray<MembershipRowToDelete>,
 ) {
   if (toDelete.length === 0) {
     return;
   }
 
   const time = Date.now();
   const insertRows = toDelete.map(rowToDelete => [
     rowToDelete.userID,
     rowToDelete.threadID,
     -1,
     time,
     defaultSubscriptionString,
     null,
     null,
     0,
     0,
   ]);
 
   while (insertRows.length > 0) {
     const batch = insertRows.splice(0, membershipInsertBatchSize);
     const query = SQL`
       INSERT INTO memberships (user, thread, role, creation_time, subscription,
         permissions, permissions_for_children, last_message, last_read_message)
       VALUES ${batch}
       ON DUPLICATE KEY UPDATE
         role = -1,
         permissions = NULL,
         permissions_for_children = NULL,
         subscription = ${defaultSubscriptionString},
         last_message = 0,
         last_read_message = 0
     `;
     await dbQuery(query);
   }
 }
 
 // Specify non-empty changedThreadIDs to force updates to be generated for those
 // threads, presumably for reasons not covered in the changeset. calendarQuery
 // only needs to be specified if a JOIN_THREAD update will be generated for the
 // viewer, in which case it's necessary for knowing the set of entries to fetch.
 type ChangesetCommitResult = {
   ...FetchThreadInfosResult,
   ...CreateUpdatesResult,
 };
 async function commitMembershipChangeset(
   viewer: Viewer,
   changeset: Changeset,
   {
     changedThreadIDs = new Set(),
     calendarQuery,
     updatesForCurrentSession = 'return',
   }: {
     +changedThreadIDs?: Set<string>,
     +calendarQuery?: ?CalendarQuery,
     +updatesForCurrentSession?: UpdatesForCurrentSession,
   } = {},
 ): Promise<ChangesetCommitResult> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
   const { membershipRows, relationshipChangeset } = changeset;
 
   const membershipRowMap = new Map();
   for (const row of membershipRows) {
     const { userID, threadID } = row;
     changedThreadIDs.add(threadID);
 
     const pairString = `${userID}|${threadID}`;
     const existing = membershipRowMap.get(pairString);
     invariant(
       !existing || existing.intent === 'none' || row.intent === 'none',
       `multiple intents provided for ${pairString}`,
     );
     if (!existing || existing.intent === 'none') {
       membershipRowMap.set(pairString, row);
     }
   }
 
   const toSave = [],
     toDelete = [],
     toRescindPushNotifs = [];
   for (const row of membershipRowMap.values()) {
     if (
       row.operation === 'delete' ||
       (row.operation === 'save' && Number(row.role) <= 0)
     ) {
       const { userID, threadID } = row;
       toRescindPushNotifs.push({ userID, threadID });
     }
     if (row.operation === 'delete') {
       toDelete.push(row);
     } else {
       toSave.push(row);
     }
   }
 
   const threadsToSavedUsers = new Map();
   for (const row of membershipRowMap.values()) {
     const { userID, threadID } = row;
     let savedUsers = threadsToSavedUsers.get(threadID);
     if (!savedUsers) {
       savedUsers = [];
       threadsToSavedUsers.set(threadID, savedUsers);
     }
     savedUsers.push(userID);
   }
   for (const [threadID, savedUsers] of threadsToSavedUsers) {
     if (threadID !== genesis.id) {
       relationshipChangeset.setAllRelationshipsNeeded(savedUsers);
     }
   }
   const relationshipRows = relationshipChangeset.getRows();
 
   const [updateDatas] = await Promise.all([
     updateChangedUndirectedRelationships(relationshipRows),
     saveMemberships(toSave),
     deleteMemberships(toDelete),
     rescindPushNotifsForMemberDeletion(toRescindPushNotifs),
   ]);
 
   // We fetch all threads here because old clients still expect the full list of
   // threads on most thread operations. Once verifyClientSupported gates on
   // codeVersion 62, we can add a WHERE clause on changedThreadIDs here
   const serverThreadInfoFetchResult = await fetchServerThreadInfos();
   const { threadInfos: serverThreadInfos } = serverThreadInfoFetchResult;
 
   const time = Date.now();
   for (const changedThreadID of changedThreadIDs) {
     const serverThreadInfo = serverThreadInfos[changedThreadID];
     for (const memberInfo of serverThreadInfo.members) {
       const pairString = `${memberInfo.id}|${serverThreadInfo.id}`;
       const membershipRow = membershipRowMap.get(pairString);
       if (membershipRow) {
         continue;
       }
       updateDatas.push({
         type: updateTypes.UPDATE_THREAD,
         userID: memberInfo.id,
         time,
         threadID: changedThreadID,
       });
     }
   }
   for (const row of membershipRowMap.values()) {
     const { userID, threadID } = row;
     if (row.operation === 'delete' || row.role === '-1') {
       if (row.oldRole !== '-1') {
         updateDatas.push({
           type: updateTypes.DELETE_THREAD,
           userID,
           time,
           threadID,
         });
       }
     } else if (row.userNeedsFullThreadDetails) {
       updateDatas.push({
         type: updateTypes.JOIN_THREAD,
         userID,
         time,
         threadID,
       });
     } else {
       updateDatas.push({
         type: updateTypes.UPDATE_THREAD,
         userID,
         time,
         threadID,
       });
     }
   }
 
   const threadInfoFetchResult = rawThreadInfosFromServerThreadInfos(
     viewer,
     serverThreadInfoFetchResult,
   );
   const { viewerUpdates, userInfos } = await createUpdates(updateDatas, {
     viewer,
     calendarQuery,
     ...threadInfoFetchResult,
     updatesForCurrentSession,
   });
 
   return {
     ...threadInfoFetchResult,
     userInfos,
     viewerUpdates,
   };
 }
 
 // When the user tries to create a new thread, it's possible for the client to
 // fail the creation even if a row gets added to the threads table. This may
 // occur due to a timeout (on either the client or server side), or due to some
 // error in the server code following the INSERT operation. Handling the error
 // scenario is more challenging since it would require detecting which set of
 // operations failed so we could retry them. As a result, this code is geared at
 // only handling the timeout scenario.
 async function getChangesetCommitResultForExistingThread(
   viewer: Viewer,
   threadID: string,
   otherUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   {
     calendarQuery,
     updatesForCurrentSession = 'return',
   }: {
     +calendarQuery?: ?CalendarQuery,
     +updatesForCurrentSession?: UpdatesForCurrentSession,
   } = {},
 ): Promise<CreateUpdatesResult> {
   for (const update of otherUpdates) {
     if (
       update.type === updateTypes.JOIN_THREAD &&
       update.threadInfo.id === threadID
     ) {
       // If the JOIN_THREAD is already there we can expect
       // the appropriate UPDATE_USERs to be covered as well
       return { viewerUpdates: otherUpdates, userInfos: {} };
     }
   }
 
   const time = Date.now();
   const updateDatas = [
     {
       type: updateTypes.JOIN_THREAD,
       userID: viewer.userID,
       time,
       threadID,
       targetSession: viewer.session,
     },
   ];
 
   // To figure out what UserInfos might be missing, we consider the worst case:
   // the same client previously attempted to create a thread with a non-friend
   // they found via search results, but the request timed out. In this scenario
   // the viewer might never have received the UPDATE_USER that would add that
   // UserInfo to their UserStore, but the server assumed the client had gotten
   // it because createUpdates was called with UpdatesForCurrentSession=return.
   // For completeness here we query for the full list of memberships rows in the
   // thread. We can't use fetchServerThreadInfos because it skips role=-1 rows
   const membershipsQuery = SQL`
     SELECT user
     FROM memberships
     WHERE thread = ${threadID} AND user != ${viewer.userID}
   `;
   const [results] = await dbQuery(membershipsQuery);
   for (const row of results) {
     updateDatas.push({
       type: updateTypes.UPDATE_USER,
       userID: viewer.userID,
       time,
       updatedUserID: row.user.toString(),
       targetSession: viewer.session,
     });
   }
 
   const { viewerUpdates, userInfos } = await createUpdates(updateDatas, {
     viewer,
     calendarQuery,
     updatesForCurrentSession,
   });
   return { viewerUpdates: [...otherUpdates, ...viewerUpdates], userInfos };
 }
 
 const rescindPushNotifsBatchSize = 3;
 async function rescindPushNotifsForMemberDeletion(
   toRescindPushNotifs: $ReadOnlyArray<{ +userID: string, +threadID: string }>,
 ): Promise<void> {
   const queue = [...toRescindPushNotifs];
   while (queue.length > 0) {
     const batch = queue.splice(0, rescindPushNotifsBatchSize);
     await Promise.all(
       batch.map(({ userID, threadID }) =>
         rescindPushNotifs(
           SQL`n.thread = ${threadID} AND n.user = ${userID}`,
           SQL`IF(m.thread = ${threadID}, NULL, m.thread)`,
         ),
       ),
     );
   }
 }
 
 async function recalculateAllThreadPermissions() {
   const getAllThreads = SQL`SELECT id FROM threads`;
   const [result] = await dbQuery(getAllThreads);
 
   // We handle each thread one-by-one to avoid a situation where a permission
   // calculation for a child thread, done during a call to
   // recalculateThreadPermissions for the parent thread, can be incorrectly
   // overriden by a call to recalculateThreadPermissions for the child thread.
   // If the changeset resulting from the parent call isn't committed before the
   // calculation is done for the child, the calculation done for the child can
   // be incorrect.
   const viewer = createScriptViewer(bots.commbot.userID);
   for (const row of result) {
     const threadID = row.id.toString();
     const changeset = await recalculateThreadPermissions(threadID);
     await commitMembershipChangeset(viewer, changeset);
   }
 }
 
 async function updateRolesAndPermissionsForAllThreads() {
   const batchSize = 10;
   const fetchThreads = SQL`SELECT id, type, depth FROM threads`;
   const [result] = await dbQuery(fetchThreads);
   const allThreads = result.map(row => {
     return {
       id: row.id.toString(),
       type: assertThreadType(row.type),
       depth: row.depth,
     };
   });
 
   const viewer = createScriptViewer(bots.commbot.userID);
 
   const maxDepth = Math.max(...allThreads.map(row => row.depth));
 
   for (let depth = 0; depth <= maxDepth; depth++) {
     const threads = allThreads.filter(row => row.depth === depth);
     console.log(`recalculating permissions for threads with depth ${depth}`);
     while (threads.length > 0) {
       const batch = threads.splice(0, batchSize);
       const membershipRows = [];
       const relationshipChangeset = new RelationshipChangeset();
       await Promise.all(
         batch.map(async thread => {
           console.log(`updating roles for ${thread.id}`);
           await updateRoles(viewer, thread.id, thread.type);
           console.log(`recalculating permissions for ${thread.id}`);
           const {
             membershipRows: threadMembershipRows,
             relationshipChangeset: threadRelationshipChangeset,
           } = await recalculateThreadPermissions(thread.id);
           membershipRows.push(...threadMembershipRows);
           relationshipChangeset.addAll(threadRelationshipChangeset);
         }),
       );
       console.log(`committing batch ${JSON.stringify(batch)}`);
       await commitMembershipChangeset(viewer, {
         membershipRows,
         relationshipChangeset,
       });
     }
   }
 }
 
 export {
   changeRole,
   recalculateThreadPermissions,
   getChangesetCommitResultForExistingThread,
   saveMemberships,
   commitMembershipChangeset,
   recalculateAllThreadPermissions,
   updateRolesAndPermissionsForAllThreads,
 };
diff --git a/keyserver/src/updaters/thread-updaters.js b/keyserver/src/updaters/thread-updaters.js
index f2812f457..9897812c6 100644
--- a/keyserver/src/updaters/thread-updaters.js
+++ b/keyserver/src/updaters/thread-updaters.js
@@ -1,848 +1,841 @@
 // @flow
 
 import { filteredThreadIDs } from 'lib/selectors/calendar-filter-selectors';
 import {
   threadHasAdminRole,
   roleIsAdminRole,
   viewerIsMember,
   getThreadTypeParentRequirement,
 } from 'lib/shared/thread-utils';
 import { hasMinCodeVersion } from 'lib/shared/version-utils';
 import type { Shape } from 'lib/types/core';
 import { messageTypes, defaultNumberPerThread } from 'lib/types/message-types';
 import {
   type RoleChangeRequest,
   type ChangeThreadSettingsResult,
   type RemoveMembersRequest,
   type LeaveThreadRequest,
   type LeaveThreadResult,
   type UpdateThreadRequest,
   type ServerThreadJoinRequest,
   type ThreadJoinResult,
   threadPermissions,
   threadTypes,
 } from 'lib/types/thread-types';
 import { updateTypes } from 'lib/types/update-types';
 import { ServerError } from 'lib/utils/errors';
 import { promiseAll } from 'lib/utils/promises';
 import { firstLine } from 'lib/utils/string-utils';
 
 import createMessages from '../creators/message-creator';
 import { getRolePermissionBlobs } from '../creators/role-creator';
 import { createUpdates } from '../creators/update-creator';
 import { dbQuery, SQL } from '../database/database';
-import { getDBType } from '../database/db-config';
 import { fetchEntryInfos } from '../fetchers/entry-fetchers';
 import { fetchMessageInfos } from '../fetchers/message-fetchers';
 import {
   fetchThreadInfos,
   fetchServerThreadInfos,
   determineThreadAncestry,
 } from '../fetchers/thread-fetchers';
 import {
   checkThreadPermission,
   viewerIsMember as fetchViewerIsMember,
   checkThread,
   validateCandidateMembers,
 } from '../fetchers/thread-permission-fetchers';
 import {
   verifyUserIDs,
   verifyUserOrCookieIDs,
 } from '../fetchers/user-fetchers';
 import type { Viewer } from '../session/viewer';
 import RelationshipChangeset from '../utils/relationship-changeset';
 import { updateRoles } from './role-updaters';
 import {
   changeRole,
   recalculateThreadPermissions,
   commitMembershipChangeset,
 } from './thread-permission-updaters';
 
 async function updateRole(
   viewer: Viewer,
   request: RoleChangeRequest,
 ): Promise<ChangeThreadSettingsResult> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const [memberIDs, hasPermission] = await Promise.all([
     verifyUserIDs(request.memberIDs),
     checkThreadPermission(
       viewer,
       request.threadID,
       threadPermissions.CHANGE_ROLE,
     ),
   ]);
   if (memberIDs.length === 0) {
     throw new ServerError('invalid_parameters');
   }
   if (!hasPermission) {
     throw new ServerError('invalid_credentials');
   }
 
   const query = SQL`
     SELECT user, role
     FROM memberships
     WHERE user IN (${memberIDs}) AND thread = ${request.threadID}
   `;
   const [result] = await dbQuery(query);
 
   let nonMemberUser = false;
   let numResults = 0;
   for (const row of result) {
     if (row.role <= 0) {
       nonMemberUser = true;
       break;
     }
     numResults++;
   }
   if (nonMemberUser || numResults < memberIDs.length) {
     throw new ServerError('invalid_parameters');
   }
 
   const changeset = await changeRole(request.threadID, memberIDs, request.role);
   const { threadInfos, viewerUpdates } = await commitMembershipChangeset(
     viewer,
     changeset,
   );
 
   const messageData = {
     type: messageTypes.CHANGE_ROLE,
     threadID: request.threadID,
     creatorID: viewer.userID,
     time: Date.now(),
     userIDs: memberIDs,
     newRole: request.role,
   };
   const newMessageInfos = await createMessages(viewer, [messageData]);
 
   if (hasMinCodeVersion(viewer.platformDetails, 62)) {
     return { updatesResult: { newUpdates: viewerUpdates }, newMessageInfos };
   }
 
   return {
     threadInfo: threadInfos[request.threadID],
     threadInfos,
     updatesResult: {
       newUpdates: viewerUpdates,
     },
     newMessageInfos,
   };
 }
 
 async function removeMembers(
   viewer: Viewer,
   request: RemoveMembersRequest,
 ): Promise<ChangeThreadSettingsResult> {
   const viewerID = viewer.userID;
   if (request.memberIDs.includes(viewerID)) {
     throw new ServerError('invalid_parameters');
   }
 
   const [memberIDs, hasPermission] = await Promise.all([
     verifyUserOrCookieIDs(request.memberIDs),
     checkThreadPermission(
       viewer,
       request.threadID,
       threadPermissions.REMOVE_MEMBERS,
     ),
   ]);
   if (memberIDs.length === 0) {
     throw new ServerError('invalid_parameters');
   }
   if (!hasPermission) {
     throw new ServerError('invalid_credentials');
   }
 
   const query = SQL`
     SELECT m.user, m.role, t.default_role
     FROM memberships m
     LEFT JOIN threads t ON t.id = m.thread
     WHERE m.user IN (${memberIDs}) AND m.thread = ${request.threadID}
   `;
   const [result] = await dbQuery(query);
 
   let nonDefaultRoleUser = false;
   const actualMemberIDs = [];
   for (const row of result) {
     if (row.role <= 0) {
       continue;
     }
     actualMemberIDs.push(row.user.toString());
     if (row.role !== row.default_role) {
       nonDefaultRoleUser = true;
     }
   }
 
   if (nonDefaultRoleUser) {
     const hasChangeRolePermission = await checkThreadPermission(
       viewer,
       request.threadID,
       threadPermissions.CHANGE_ROLE,
     );
     if (!hasChangeRolePermission) {
       throw new ServerError('invalid_credentials');
     }
   }
 
   const changeset = await changeRole(request.threadID, actualMemberIDs, 0);
   const { threadInfos, viewerUpdates } = await commitMembershipChangeset(
     viewer,
     changeset,
   );
 
   const newMessageInfos = await (async () => {
     if (actualMemberIDs.length === 0) {
       return [];
     }
     const messageData = {
       type: messageTypes.REMOVE_MEMBERS,
       threadID: request.threadID,
       creatorID: viewerID,
       time: Date.now(),
       removedUserIDs: actualMemberIDs,
     };
     return await createMessages(viewer, [messageData]);
   })();
 
   if (hasMinCodeVersion(viewer.platformDetails, 62)) {
     return { updatesResult: { newUpdates: viewerUpdates }, newMessageInfos };
   }
 
   return {
     threadInfo: threadInfos[request.threadID],
     threadInfos,
     updatesResult: {
       newUpdates: viewerUpdates,
     },
     newMessageInfos,
   };
 }
 
 async function leaveThread(
   viewer: Viewer,
   request: LeaveThreadRequest,
 ): Promise<LeaveThreadResult> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const [fetchThreadResult, hasPermission] = await Promise.all([
     fetchThreadInfos(viewer, SQL`t.id = ${request.threadID}`),
     checkThreadPermission(
       viewer,
       request.threadID,
       threadPermissions.LEAVE_THREAD,
     ),
   ]);
 
   const threadInfo = fetchThreadResult.threadInfos[request.threadID];
 
   if (!viewerIsMember(threadInfo)) {
     if (hasMinCodeVersion(viewer.platformDetails, 62)) {
       return {
         updatesResult: { newUpdates: [] },
       };
     }
     const { threadInfos } = await fetchThreadInfos(viewer);
     return {
       threadInfos,
       updatesResult: {
         newUpdates: [],
       },
     };
   }
 
   if (!hasPermission) {
     throw new ServerError('invalid_parameters');
   }
 
   const viewerID = viewer.userID;
   if (threadHasAdminRole(threadInfo)) {
     let otherUsersExist = false;
     let otherAdminsExist = false;
     for (const member of threadInfo.members) {
       const role = member.role;
       if (!role || member.id === viewerID) {
         continue;
       }
       otherUsersExist = true;
       if (roleIsAdminRole(threadInfo.roles[role])) {
         otherAdminsExist = true;
         break;
       }
     }
     if (otherUsersExist && !otherAdminsExist) {
       throw new ServerError('invalid_parameters');
     }
   }
 
   const changeset = await changeRole(request.threadID, [viewerID], 0);
   const { threadInfos, viewerUpdates } = await commitMembershipChangeset(
     viewer,
     changeset,
   );
 
   const messageData = {
     type: messageTypes.LEAVE_THREAD,
     threadID: request.threadID,
     creatorID: viewerID,
     time: Date.now(),
   };
   await createMessages(viewer, [messageData]);
 
   if (hasMinCodeVersion(viewer.platformDetails, 62)) {
     return { updatesResult: { newUpdates: viewerUpdates } };
   }
 
   return {
     threadInfos,
     updatesResult: {
       newUpdates: viewerUpdates,
     },
   };
 }
 
 type UpdateThreadOptions = Shape<{
   +forceAddMembers: boolean,
   +forceUpdateRoot: boolean,
   +silenceMessages: boolean,
   +ignorePermissions: boolean,
 }>;
 
 async function updateThread(
   viewer: Viewer,
   request: UpdateThreadRequest,
   options?: UpdateThreadOptions,
 ): Promise<ChangeThreadSettingsResult> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
   const forceAddMembers = options?.forceAddMembers ?? false;
   const forceUpdateRoot = options?.forceUpdateRoot ?? false;
   const silenceMessages = options?.silenceMessages ?? false;
   const ignorePermissions =
     (options?.ignorePermissions && viewer.isScriptViewer) ?? false;
   const validationPromises = {};
 
   const changedFields = {};
   const sqlUpdate = {};
   const untrimmedName = request.changes.name;
   if (untrimmedName !== undefined && untrimmedName !== null) {
     const name = firstLine(untrimmedName);
     changedFields.name = name;
     sqlUpdate.name = name ?? null;
   }
   const { description } = request.changes;
   if (description !== undefined && description !== null) {
     changedFields.description = description;
     sqlUpdate.description = description ?? null;
   }
   if (request.changes.color) {
     const color = request.changes.color.toLowerCase();
     changedFields.color = color;
     sqlUpdate.color = color;
   }
   const { parentThreadID } = request.changes;
   if (parentThreadID !== undefined) {
     // TODO some sort of message when this changes
     sqlUpdate.parent_thread_id = parentThreadID;
   }
 
   const threadType = request.changes.type;
   if (threadType !== null && threadType !== undefined) {
     changedFields.type = threadType;
     sqlUpdate.type = threadType;
   }
 
   if (
     !ignorePermissions &&
     threadType !== null &&
     threadType !== undefined &&
     threadType !== threadTypes.COMMUNITY_OPEN_SUBTHREAD &&
     threadType !== threadTypes.COMMUNITY_SECRET_SUBTHREAD
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   const newMemberIDs =
     request.changes.newMemberIDs && request.changes.newMemberIDs.length > 0
       ? [...new Set(request.changes.newMemberIDs)]
       : null;
 
   if (
     Object.keys(sqlUpdate).length === 0 &&
     !newMemberIDs &&
     !forceUpdateRoot
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   validationPromises.serverThreadInfos = fetchServerThreadInfos(
     SQL`t.id = ${request.threadID}`,
   );
 
   validationPromises.hasNecessaryPermissions = (async () => {
     if (ignorePermissions) {
       return;
     }
     const checks = [];
     if (sqlUpdate.name !== undefined) {
       checks.push({
         check: 'permission',
         permission: threadPermissions.EDIT_THREAD_NAME,
       });
     }
     if (sqlUpdate.description !== undefined) {
       checks.push({
         check: 'permission',
         permission: threadPermissions.EDIT_THREAD_DESCRIPTION,
       });
     }
     if (sqlUpdate.color !== undefined) {
       checks.push({
         check: 'permission',
         permission: threadPermissions.EDIT_THREAD_COLOR,
       });
     }
     if (parentThreadID !== undefined || sqlUpdate.type !== undefined) {
       checks.push({
         check: 'permission',
         permission: threadPermissions.EDIT_PERMISSIONS,
       });
     }
     if (newMemberIDs) {
       checks.push({
         check: 'permission',
         permission: threadPermissions.ADD_MEMBERS,
       });
     }
     const hasNecessaryPermissions = await checkThread(
       viewer,
       request.threadID,
       checks,
     );
     if (!hasNecessaryPermissions) {
       throw new ServerError('invalid_credentials');
     }
   })();
 
   const { serverThreadInfos } = await promiseAll(validationPromises);
 
   const serverThreadInfo = serverThreadInfos.threadInfos[request.threadID];
   if (!serverThreadInfo) {
     throw new ServerError('internal_error');
   }
 
   // Threads with source message should be visible to everyone, but we can't
   // guarantee it for COMMUNITY_SECRET_SUBTHREAD threads so we forbid it for
   // now. In the future, if we want to support this, we would need to unlink the
   // source message.
   if (
     threadType !== null &&
     threadType !== undefined &&
     threadType !== threadTypes.SIDEBAR &&
     threadType !== threadTypes.COMMUNITY_OPEN_SUBTHREAD &&
     serverThreadInfo.sourceMessageID
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   // You can't change the parent thread of a current or former SIDEBAR
   if (parentThreadID !== undefined && serverThreadInfo.sourceMessageID) {
     throw new ServerError('invalid_parameters');
   }
 
   const oldThreadType = serverThreadInfo.type;
   const oldParentThreadID = serverThreadInfo.parentThreadID;
   const oldContainingThreadID = serverThreadInfo.containingThreadID;
   const oldCommunity = serverThreadInfo.community;
   const oldDepth = serverThreadInfo.depth;
 
   const nextThreadType =
     threadType !== null && threadType !== undefined
       ? threadType
       : oldThreadType;
   let nextParentThreadID =
     parentThreadID !== undefined ? parentThreadID : oldParentThreadID;
 
   // Does the new thread type preclude a parent?
   if (
     threadType !== undefined &&
     threadType !== null &&
     getThreadTypeParentRequirement(threadType) === 'disabled' &&
     nextParentThreadID !== null
   ) {
     nextParentThreadID = null;
     sqlUpdate.parent_thread_id = null;
   }
 
   // Does the new thread type require a parent?
   if (
     threadType !== undefined &&
     threadType !== null &&
     getThreadTypeParentRequirement(threadType) === 'required' &&
     nextParentThreadID === null
   ) {
     throw new ServerError('no_parent_thread_specified');
   }
 
   const determineThreadAncestryPromise = determineThreadAncestry(
     nextParentThreadID,
     nextThreadType,
   );
 
   const confirmParentPermissionPromise = (async () => {
     if (ignorePermissions || !nextParentThreadID) {
       return;
     }
     if (
       nextParentThreadID === oldParentThreadID &&
       (nextThreadType === threadTypes.SIDEBAR) ===
         (oldThreadType === threadTypes.SIDEBAR)
     ) {
       return;
     }
     const hasParentPermission = await checkThreadPermission(
       viewer,
       nextParentThreadID,
       nextThreadType === threadTypes.SIDEBAR
         ? threadPermissions.CREATE_SIDEBARS
         : threadPermissions.CREATE_SUBCHANNELS,
     );
     if (!hasParentPermission) {
       throw new ServerError('invalid_parameters');
     }
   })();
 
   const rolesNeedUpdate = forceUpdateRoot || nextThreadType !== oldThreadType;
 
   const validateNewMembersPromise = (async () => {
     if (!newMemberIDs || ignorePermissions) {
       return;
     }
 
     const defaultRolePermissionsPromise = (async () => {
       let rolePermissions;
       if (!rolesNeedUpdate) {
         const rolePermissionsQuery = SQL`
           SELECT r.permissions
           FROM threads t
           LEFT JOIN roles r ON r.id = t.default_role
           WHERE t.id = ${request.threadID}
         `;
-        const [[result], dbType] = await Promise.all([
-          dbQuery(rolePermissionsQuery),
-          getDBType(),
-        ]);
+        const [result] = await dbQuery(rolePermissionsQuery);
         if (result.length > 0) {
-          rolePermissions =
-            dbType === 'mysql5.7'
-              ? result[0].permissions
-              : JSON.parse(result[0].permissions);
+          rolePermissions = JSON.parse(result[0].permissions);
         }
       }
       if (!rolePermissions) {
         rolePermissions = getRolePermissionBlobs(nextThreadType).Members;
       }
       return rolePermissions;
     })();
 
     const [defaultRolePermissions, nextThreadAncestry] = await Promise.all([
       defaultRolePermissionsPromise,
       determineThreadAncestryPromise,
     ]);
 
     const { newMemberIDs: validatedIDs } = await validateCandidateMembers(
       viewer,
       { newMemberIDs },
       {
         threadType: nextThreadType,
         parentThreadID: nextParentThreadID,
         containingThreadID: nextThreadAncestry.containingThreadID,
         defaultRolePermissions,
       },
       { requireRelationship: !forceAddMembers },
     );
     if (
       validatedIDs &&
       Number(validatedIDs?.length) < Number(newMemberIDs?.length)
     ) {
       throw new ServerError('invalid_credentials');
     }
   })();
 
   const { nextThreadAncestry } = await promiseAll({
     nextThreadAncestry: determineThreadAncestryPromise,
     confirmParentPermissionPromise,
     validateNewMembersPromise,
   });
   if (nextThreadAncestry.containingThreadID !== oldContainingThreadID) {
     sqlUpdate.containing_thread_id = nextThreadAncestry.containingThreadID;
   }
   if (nextThreadAncestry.community !== oldCommunity) {
     if (!ignorePermissions) {
       throw new ServerError('invalid_parameters');
     }
     sqlUpdate.community = nextThreadAncestry.community;
   }
   if (nextThreadAncestry.depth !== oldDepth) {
     sqlUpdate.depth = nextThreadAncestry.depth;
   }
 
   const updateQueryPromise = (async () => {
     if (Object.keys(sqlUpdate).length === 0) {
       return;
     }
     const updateQuery = SQL`
       UPDATE threads SET ${sqlUpdate} WHERE id = ${request.threadID}
     `;
     await dbQuery(updateQuery);
   })();
 
   const updateRolesPromise = (async () => {
     if (rolesNeedUpdate) {
       await updateRoles(viewer, request.threadID, nextThreadType);
     }
   })();
 
   const intermediatePromises = {};
   intermediatePromises.updateQuery = updateQueryPromise;
   intermediatePromises.updateRoles = updateRolesPromise;
 
   if (newMemberIDs) {
     intermediatePromises.addMembersChangeset = (async () => {
       await Promise.all([updateQueryPromise, updateRolesPromise]);
       return await changeRole(request.threadID, newMemberIDs, null, {
         setNewMembersToUnread: true,
       });
     })();
   }
 
   const threadRootChanged =
     rolesNeedUpdate || nextParentThreadID !== oldParentThreadID;
   if (threadRootChanged) {
     intermediatePromises.recalculatePermissionsChangeset = (async () => {
       await Promise.all([updateQueryPromise, updateRolesPromise]);
       return await recalculateThreadPermissions(request.threadID);
     })();
   }
 
   const {
     addMembersChangeset,
     recalculatePermissionsChangeset,
   } = await promiseAll(intermediatePromises);
 
   const membershipRows = [];
   const relationshipChangeset = new RelationshipChangeset();
   if (recalculatePermissionsChangeset) {
     const {
       membershipRows: recalculateMembershipRows,
       relationshipChangeset: recalculateRelationshipChangeset,
     } = recalculatePermissionsChangeset;
     membershipRows.push(...recalculateMembershipRows);
     relationshipChangeset.addAll(recalculateRelationshipChangeset);
   }
   let addedMemberIDs;
   if (addMembersChangeset) {
     const {
       membershipRows: addMembersMembershipRows,
       relationshipChangeset: addMembersRelationshipChangeset,
     } = addMembersChangeset;
     addedMemberIDs = addMembersMembershipRows
       .filter(row => row.operation === 'save' && Number(row.role) > 0)
       .map(row => row.userID);
     membershipRows.push(...addMembersMembershipRows);
     relationshipChangeset.addAll(addMembersRelationshipChangeset);
   }
 
   const changeset = { membershipRows, relationshipChangeset };
   const { threadInfos, viewerUpdates } = await commitMembershipChangeset(
     viewer,
     changeset,
     {
       // This forces an update for this thread,
       // regardless of whether any membership rows are changed
       changedThreadIDs:
         Object.keys(sqlUpdate).length > 0
           ? new Set([request.threadID])
           : new Set(),
     },
   );
 
   let newMessageInfos = [];
   if (!silenceMessages) {
     const time = Date.now();
     const messageDatas = [];
     for (const fieldName in changedFields) {
       const newValue = changedFields[fieldName];
       messageDatas.push({
         type: messageTypes.CHANGE_SETTINGS,
         threadID: request.threadID,
         creatorID: viewer.userID,
         time,
         field: fieldName,
         value: newValue,
       });
     }
     if (addedMemberIDs && addedMemberIDs.length > 0) {
       messageDatas.push({
         type: messageTypes.ADD_MEMBERS,
         threadID: request.threadID,
         creatorID: viewer.userID,
         time,
         addedUserIDs: addedMemberIDs,
       });
     }
     newMessageInfos = await createMessages(viewer, messageDatas);
   }
 
   if (hasMinCodeVersion(viewer.platformDetails, 62)) {
     return { updatesResult: { newUpdates: viewerUpdates }, newMessageInfos };
   }
 
   return {
     threadInfo: threadInfos[request.threadID],
     threadInfos,
     updatesResult: {
       newUpdates: viewerUpdates,
     },
     newMessageInfos,
   };
 }
 
 async function joinThread(
   viewer: Viewer,
   request: ServerThreadJoinRequest,
 ): Promise<ThreadJoinResult> {
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const [isMember, hasPermission] = await Promise.all([
     fetchViewerIsMember(viewer, request.threadID),
     checkThreadPermission(
       viewer,
       request.threadID,
       threadPermissions.JOIN_THREAD,
     ),
   ]);
   if (!hasPermission) {
     throw new ServerError('invalid_parameters');
   }
 
   // TODO: determine code version
   const hasCodeVersionBelow87 = !hasMinCodeVersion(viewer.platformDetails, 87);
   const hasCodeVersionBelow62 = !hasMinCodeVersion(viewer.platformDetails, 62);
 
   const { calendarQuery } = request;
   if (isMember) {
     const response: ThreadJoinResult = {
       rawMessageInfos: [],
       truncationStatuses: {},
       userInfos: {},
       updatesResult: {
         newUpdates: [],
       },
     };
     if (calendarQuery && hasCodeVersionBelow87) {
       response.rawEntryInfos = [];
     }
     if (hasCodeVersionBelow62) {
       response.threadInfos = {};
     }
     return response;
   }
 
   if (calendarQuery) {
     const threadFilterIDs = filteredThreadIDs(calendarQuery.filters);
     if (
       !threadFilterIDs ||
       threadFilterIDs.size !== 1 ||
       threadFilterIDs.values().next().value !== request.threadID
     ) {
       throw new ServerError('invalid_parameters');
     }
   }
 
   const changeset = await changeRole(request.threadID, [viewer.userID], null);
 
   const membershipResult = await commitMembershipChangeset(viewer, changeset, {
     calendarQuery,
   });
 
   const messageData = {
     type: messageTypes.JOIN_THREAD,
     threadID: request.threadID,
     creatorID: viewer.userID,
     time: Date.now(),
   };
   const newMessages = await createMessages(viewer, [messageData]);
 
   const messageSelectionCriteria = {
     threadCursors: { [request.threadID]: false },
   };
 
   if (!hasCodeVersionBelow87) {
     return {
       rawMessageInfos: newMessages,
       truncationStatuses: {},
       userInfos: membershipResult.userInfos,
       updatesResult: {
         newUpdates: membershipResult.viewerUpdates,
       },
     };
   }
 
   const [fetchMessagesResult, fetchEntriesResult] = await Promise.all([
     fetchMessageInfos(viewer, messageSelectionCriteria, defaultNumberPerThread),
     calendarQuery ? fetchEntryInfos(viewer, [calendarQuery]) : undefined,
   ]);
   const rawEntryInfos = fetchEntriesResult && fetchEntriesResult.rawEntryInfos;
   const response: ThreadJoinResult = {
     rawMessageInfos: fetchMessagesResult.rawMessageInfos,
     truncationStatuses: fetchMessagesResult.truncationStatuses,
     userInfos: membershipResult.userInfos,
     updatesResult: {
       newUpdates: membershipResult.viewerUpdates,
     },
   };
   if (hasCodeVersionBelow62) {
     response.threadInfos = membershipResult.threadInfos;
   }
   if (rawEntryInfos) {
     response.rawEntryInfos = rawEntryInfos;
   }
   return response;
 }
 
 async function updateThreadMembers(viewer: Viewer) {
   const { threadInfos } = await fetchThreadInfos(
     viewer,
     SQL`t.parent_thread_id IS NOT NULL `,
   );
 
   const updateDatas = [];
   const time = Date.now();
   for (const threadID in threadInfos) {
     updateDatas.push({
       type: updateTypes.UPDATE_THREAD,
       userID: viewer.id,
       time,
       threadID: threadID,
       targetSession: viewer.session,
     });
   }
 
   await createUpdates(updateDatas);
 }
 
 export {
   updateRole,
   removeMembers,
   leaveThread,
   updateThread,
   joinThread,
   updateThreadMembers,
 };