Limit the selection of data (the last document for each ID searched for) from the collection

I'm trying to get an array of recent user messages for each chat room. But in my version I get just an array of messages that have been sent for all the chats.

func (r *Mongo) findLastMessages(ctx context.Context, chatIds []string) ([]*Message, error) {

	if len(chatIds) == 0 {
		return nil, nil
	}

	query := bson.M{"chat_id": bson.M{"$in": chatIds}}
	cursor, err := r.colMessage.Find(ctx, query, nil)
	if err != nil {
		return nil, err
	}

	var messages []*Message
	if err = cursor.All(ctx, &messages); err != nil {
		return nil, err
	}

	err = cursor.Close(ctx)
	if err != nil {
		return nil, ErrInternal
	}

	return messages, err
}

Is there any way I can filter the sample so that I get only one last message for each chat?

And

Perhaps you should use aggregations for such purposes? If so, is it better to cycle Find or use aggregations?

Assuming that by "last" you mean the one with the most recent timestamp, I can think of 2 ways to do it.

Both will perform better if there is an index on chat_id:1, timestamp:1

1. Find matching a single chat_it, sort by timestamp descending, with a limit of 1. This would require loading only the desired document, for a 1:1 scanned returned ratio. Repeat for each chat

2. Aggregation to match an array ofchats at once, sort by timestamp, and then group by chat_id selecting only the first message from each. This would require loading many messages from each chat. However, this method would return all of the documents in a single operation with a single network round trip.

Which method is better for you would depend on:

• how expensive is the network round trip
• how much delay will there be due to the resource overhead of scanning all of the extra documents
• how often the query will run
• how many instances of the query will be run simultaneously