Is it better to do one db request and process data in application, or fetch data from db in multiple queries

I have around ~100 inventory of different types saved in db for a property
Is it better to have code like this

List<Inventory> type1s = inventoryRepo.findByPropertyIdAndType(propertyId, Type1);
List<Inventory> type2s = inventoryRepo.findByPropertyIdAndType(propertyId, Type2);
Map<InventoryType, List<Inventory>> typeListMap = new HashMap<>();
typeListMap.put(Type1, type1s);
typeListMap.put(Type2, type2s);

or

List<Inventory> inventories = inventoryRepo.findByPropertyIdAndTypeIn(propertyId
        , Arrays.asList(Type1, Type2));
Map<InventoryType, List<Inventory>> typeListMap = inventories.stream().collect(
        Collectors.groupingBy(Inventory::getType, Collectors.toList()));

Note: DB is postgresql.
I think 2nd approach is better, going by the rule of having min db calls. But am I missing some other key aspects to be considered?

As it is always with these question, the answer is - it depends.

If there is not much data to process, then single roundtrip would be optimal.

On the other hand when the amount of data grows, the problems arise:

1. The application memory might not be sufficient and OutOfMemoryError might be thrown.

2. The database can be unresponsive because it has to process a costly query.

In that case batching is usually the most reasonable approach.

It is better if you fetch the data from db at once and then process it in the application as it's always advisable to have less load on the database if you ever scale.

Up to a point, the fastest approach is to gather all data at once. Above that point, it would be advisable to separate the data into chunks of, say, 10K rows at a time.

It's up to you to discover the point at which it would be best to split, and the optimal chunk size.

I can't think of any scenario in which selecting one row at a time would be faster.