def insert_audit_log_entry(self, txact, guild, entry):
self.logger.debug(
f"Inserting audit log entry {entry.id} from {guild.name}")
data = AuditLogData(entry, guild)
values = data.values()
ins = (p_insert(
self.tb_audit_log).values(values).on_conflict_do_nothing(
index_elements=["audit_entry_id"]))
txact.execute(ins)
def upsert_member(self, txact, member):
self.logger.debug(f"Upserting member data for {member.id}")
values = guild_member_values(member)
ups = (p_insert(
self.tb_guild_membership).values(values).on_conflict_do_update(
constraint="uq_guild_membership",
set_=values,
))
txact.execute(ups)
self._delete_role_membership(txact, member)
self._insert_role_membership(txact, member)
def upsert_channel(self, txact, channel):
values = channel_values(channel)
if self.channel_cache.get(channel.id) == values:
self.logger.debug(
f"Channel lookup for {channel.id} is already up-to-date")
return
self.logger.debug(f"Updating lookup data for channel #{channel.name}")
ups = (p_insert(self.tb_channels).values(values).on_conflict_do_update(
index_elements=["channel_id"],
index_where=(self.tb_channels.c.channel_id == channel.id),
set_=values,
))
txact.execute(ups)
self.channel_cache[channel.id] = values
def upsert_role(self, txact, role):
values = role_values(role)
if self.role_cache.get(role.id) == values:
self.logger.debug(
f"Role lookup for {role.id} is already up-to-date")
return
self.logger.debug(f"Updating lookup data for role {role.name}")
ups = (p_insert(self.tb_roles).values(values).on_conflict_do_update(
index_elements=["role_id"],
index_where=(self.tb_roles.c.role_id == role.id),
set_=values,
))
txact.execute(ups)
self.role_cache[role.id] = values
def upsert_guild(self, txact, guild):
values = guild_values(guild)
if self.guild_cache.get(guild.id) == values:
self.logger.debug(
f"Guild lookup for {guild.id} is already up-to-date")
return
self.logger.info(f"Updating lookup data for guild {guild.name}")
ups = (p_insert(self.tb_guilds).values(values).on_conflict_do_update(
index_elements=["guild_id"],
index_where=(self.tb_guilds.c.guild_id == guild.id),
set_=values,
))
txact.conn.execute(ups)
self.guild_cache[guild.id] = values
def upsert_user(self, txact, user):
self.logger.debug(f"Upserting user {user.id}")
values = user_values(user)
if self.user_cache.get(user.id) == values:
self.logger.debug(
f"User lookup for {user.id} is already up-to-date")
return
ups = (p_insert(self.tb_users).values(values).on_conflict_do_update(
index_elements=["int_user_id"],
index_where=(self.tb_users.c.int_user_id == int_hash(user.id)),
set_=values,
))
txact.execute(ups)
self.user_cache[user.id] = values
def insert_message(self, txact, message):
values = message_values(message)
if self.message_cache.get(message.id) == values:
self.logger.debug(
f"Message lookup for {message.id} is already up-to-date")
return
self.logger.debug(f"Inserting message {message.id}")
ins = (p_insert(
self.tb_messages).values(values).on_conflict_do_nothing(
index_elements=["message_id"]))
txact.execute(ins)
self.message_cache[message.id] = values
self.upsert_user(txact, message.author)
self.insert_mentions(txact, message)
def upsert_emoji(self, txact, emoji):
data = EmojiData(emoji)
values = data.values()
if self.emoji_cache.get(data.cache_id) == values:
self.logger.debug(f"Emoji lookup for {data} is already up-to-date")
return
self.logger.debug(f"Upserting emoji {data}")
ups = (p_insert(self.tb_emojis).values(values).on_conflict_do_update(
index_elements=["emoji_id", "emoji_unicode"],
index_where=and_(
self.tb_emojis.c.emoji_id == data.id,
self.tb_emojis.c.emoji_unicode == data.unicode,
),
set_=values,
))
txact.execute(ups)
self.emoji_cache[data.cache_id] = values
def insert_reaction(self, txact, reaction, users):
self.logger.debug(
f"Inserting past reactions for {reaction.message.id}")
self.upsert_emoji(txact, reaction.emoji)
data = EmojiData(reaction.emoji)
for user in users:
self.upsert_user(txact, user)
values = reaction_values(reaction, user, False)
self.logger.debug(
f"Inserting single reaction {data} from {user.id}")
ins = (p_insert(
self.tb_reactions).values(values).on_conflict_do_nothing(
index_elements=[
"message_id",
"emoji_id",
"emoji_unicode",
"int_user_id",
"created_at",
]))
txact.execute(ins)
def insert_mentions(self, txact, message):
self.logger.debug(f"Inserting all mentions in message {message.id}")
for id in message.raw_mentions:
if id > MAX_ID:
self.logger.error(f"User mention was too long: {id}")
continue
self.logger.debug(f"User mention: {id}")
ins = (p_insert(self.tb_mentions).values({
"mentioned_id":
id,
"type":
MentionType.USER,
"message_id":
message.id,
"channel_id":
message.channel.id,
"guild_id":
message.guild.id,
}).on_conflict_do_nothing(
index_elements=["mentioned_id", "type", "message_id"]))
txact.execute(ins)
for id in message.raw_role_mentions:
if id > MAX_ID:
self.logger.error(f"Role mention was too long: {id}")
continue
self.logger.debug(f"Role mention: {id}")
ins = (p_insert(self.tb_mentions).values({
"mentioned_id":
id,
"type":
MentionType.ROLE,
"message_id":
message.id,
"channel_id":
message.channel.id,
"guild_id":
message.guild.id,
}).on_conflict_do_nothing(
index_elements=["mentioned_id", "type", "message_id"]))
txact.execute(ins)
for id in message.raw_channel_mentions:
if id > MAX_ID:
self.logger.error(f"Channel mention was too long: {id}")
continue
self.logger.debug(f"Channel mention: {id}")
ins = (p_insert(self.tb_mentions).values({
"mentioned_id":
id,
"type":
MentionType.CHANNEL,
"message_id":
message.id,
"channel_id":
message.channel.id,
"guild_id":
message.guild.id,
}).on_conflict_do_nothing(
index_elements=["mentioned_id", "type", "message_id"]))
txact.execute(ins)
