From 332f6a2586a4133cce94aff3b1c4e124f2af55c2 Mon Sep 17 00:00:00 2001 From: Classic298 <27028174+Classic298@users.noreply.github.com> Date: Wed, 4 Nov 2026 22:43:25 +0100 Subject: [PATCH] perf: channel list loads much faster with many channels (#33690) Opening the channel list ran several database queries for every channel, so the load time grew with the number of channels. The last message time, unread count, mute state and direct message participants are now fetched for all channels at once, so the number of queries stays the same no matter how many channels a user has. The response is unchanged. Measured on SQLite with an admin user in 23 visible channels (50 seeded), 2000 messages per channel: | | before | after | |---|---|---| | database queries | 93 | 9 | | response time | 255 ms | 47 ms | --- backend/open_webui/models/channels.py | 27 ++++++++++++++++++ backend/open_webui/models/messages.py | 33 ++++++++++++++++++---- backend/open_webui/routers/channels.py | 38 +++++++++++++++----------- 3 files changed, 76 insertions(+), 22 deletions(-) diff --git a/backend/open_webui/models/channels.py b/backend/open_webui/models/channels.py index 1f0d15f47b..179ed83fd2 100644 --- a/backend/open_webui/models/channels.py +++ b/backend/open_webui/models/channels.py @@ -613,6 +613,33 @@ class ChannelTable: memberships = result.scalars().all() return [ChannelMemberModel.model_validate(membership) for membership in memberships] + async def get_members_by_user_id_and_channel_ids( + self, user_id: str, channel_ids: list[str], db: Optional[AsyncSession] = None + ) -> dict[str, ChannelMemberModel]: + async with get_async_db_context(db) as db: + result = await db.execute( + select(ChannelMember).filter( + ChannelMember.channel_id.in_(channel_ids), + ChannelMember.user_id == user_id, + ) + ) + return { + membership.channel_id: ChannelMemberModel.model_validate(membership) + for membership in result.scalars().all() + } + + async def get_members_by_channel_ids( + self, channel_ids: list[str], db: Optional[AsyncSession] = None + ) -> list[ChannelMemberModel]: + async with get_async_db_context(db) as db: + result = await db.execute( + select(ChannelMember).filter( + ChannelMember.channel_id.in_(channel_ids), ChannelMember.user_id.is_not(None) + ) + ) + memberships = result.scalars().all() + return [ChannelMemberModel.model_validate(membership) for membership in memberships] + async def pin_channel( self, channel_id: str, diff --git a/backend/open_webui/models/messages.py b/backend/open_webui/models/messages.py index 0ba78c2eb2..e4c58e5de2 100644 --- a/backend/open_webui/models/messages.py +++ b/backend/open_webui/models/messages.py @@ -513,15 +513,36 @@ class MessageTable: ) return messages - async def get_last_message_by_channel_id( - self, channel_id: str, db: Optional[AsyncSession] = None - ) -> Optional[MessageModel]: + async def get_last_message_times_by_channel_ids( + self, channel_ids: list[str], db: Optional[AsyncSession] = None + ) -> dict[str, int]: async with get_async_db_context(db) as db: result = await db.execute( - select(Message).filter_by(channel_id=channel_id).order_by(Message.created_at.desc()).limit(1) + select(Message.channel_id, func.max(Message.created_at)) + .filter(Message.channel_id.in_(channel_ids)) + .group_by(Message.channel_id) ) - message = result.scalars().first() - return MessageModel.model_validate(message) if message else None + return dict(result.all()) + + async def get_unread_message_counts_by_user_id( + self, user_id: str, channel_ids: list[str], db: Optional[AsyncSession] = None + ) -> dict[str, int]: + async with get_async_db_context(db) as db: + result = await db.execute( + select(Message.channel_id, func.count(Message.id)) + .join( + ChannelMember, + and_(ChannelMember.channel_id == Message.channel_id, ChannelMember.user_id == user_id), + ) + .filter( + Message.channel_id.in_(channel_ids), + Message.parent_id == None, # only count top-level messages + Message.created_at > func.coalesce(ChannelMember.last_read_at, 0), + or_(Message.user_id != user_id, Message.user_id.is_(None)), + ) + .group_by(Message.channel_id) + ) + return dict(result.all()) async def get_pinned_messages_by_channel_id( self, diff --git a/backend/open_webui/routers/channels.py b/backend/open_webui/routers/channels.py index 37e11b9d1b..e5b160960f 100644 --- a/backend/open_webui/routers/channels.py +++ b/backend/open_webui/routers/channels.py @@ -193,40 +193,46 @@ async def get_channels( await check_channels_access(request, user) channels = await Channels.get_channels_by_user_id(user.id, db=db) + channel_ids = [channel.id for channel in channels] + dm_channel_ids = [channel.id for channel in channels if channel.type == 'dm'] + + channel_members = await Channels.get_members_by_user_id_and_channel_ids(user.id, channel_ids, db=db) + last_message_times = await Messages.get_last_message_times_by_channel_ids(channel_ids, db=db) + unread_counts = await Messages.get_unread_message_counts_by_user_id(user.id, channel_ids, db=db) + + dm_member_user_ids = {channel_id: set() for channel_id in dm_channel_ids} + for member in await Channels.get_members_by_channel_ids(dm_channel_ids, db=db): + dm_member_user_ids[member.channel_id].add(member.user_id) + all_dm_users = await Users.get_users_by_user_ids( + list({user_id for user_ids in dm_member_user_ids.values() for user_id in user_ids}), db=db + ) + channel_list = [] for channel in channels: - last_message = await Messages.get_last_message_by_channel_id(channel.id, db=db) - last_message_at = last_message.created_at if last_message else None - - channel_member = await Channels.get_member_by_channel_and_user_id(channel.id, user.id, db=db) - unread_count = ( - await Messages.get_unread_message_count(channel.id, user.id, channel_member.last_read_at, db=db) - if channel_member - else 0 - ) + channel_member = channel_members.get(channel.id) user_ids = None users = None if channel.type == 'dm': - member_user_ids = [member.user_id for member in await Channels.get_members_by_channel_id(channel.id, db=db)] users = [ UserIdNameStatusResponse( **{ - **u.model_dump(), - 'is_active': Users.is_active(u), + **dm_user.model_dump(), + 'is_active': Users.is_active(dm_user), } ) - for u in await Users.get_users_by_user_ids(member_user_ids, db=db) + for dm_user in all_dm_users + if dm_user.id in dm_member_user_ids[channel.id] ] - user_ids = [u.id for u in users] + user_ids = [dm_user.id for dm_user in users] channel_list.append( ChannelListItemResponse( **channel.model_dump(), user_ids=user_ids, users=users, - last_message_at=last_message_at, - unread_count=unread_count, + last_message_at=last_message_times.get(channel.id), + unread_count=unread_counts.get(channel.id, 0) if channel_member else 0, is_channel_muted=channel_member.is_channel_muted if channel_member else False, ) )