Firebase数据库双查询合并问题：RecyclerView展示指定时段营业餐厅

Hey there! I’ve tackled this exact scenario before, so let’s walk through the feasible solutions to combine your open and close time queries in Firebase. The key thing to remember is that Firebase Realtime Database doesn’t support multi-field AND queries out of the box, but we have workarounds depending on your data scale and needs.

1. Client-Side Filtering (Quick & Simple for Small Datasets) #

If your restaurant list isn’t massive (think hundreds, not thousands of entries), this is the fastest way to get up and running. Fetch all relevant restaurants first, then filter them locally to match your 6 AM–12 PM window.

How it works: #

We’ll pull all restaurant data, then check if their operating hours overlap with your target slot. The logic for "open between 6 AM and 12 PM" covers three scenarios:

• Restaurant opens ≤6 AM and closes ≥12 PM (covers the entire slot)
• Restaurant opens between 6–12 AM and closes ≥12 PM (stays open through the slot)
• Restaurant opens ≤6 AM and closes between 6–12 PM (stays open until the end of the slot)

Code Example (Java): #

DatabaseReference restaurantRef = FirebaseDatabase.getInstance().getReference("restaurants");

restaurantRef.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        List<Restaurant> morningOpenRestaurants = new ArrayList<>();
        
        for (DataSnapshot restaurantSnap : dataSnapshot.getChildren()) {
            Restaurant restaurant = restaurantSnap.getValue(Restaurant.class);
            int openTime = restaurant.getOpen(); // Assume stored as integer (e.g., 6 for 6 AM)
            int closeTime = restaurant.getClose(); // e.g., 14 for 2 PM

            // Check if the restaurant is open during 6–12 PM
            boolean isOpenInSlot = (openTime <= 6 && closeTime >= 12)
                                || (openTime > 6 && openTime <= 12 && closeTime >= 12)
                                || (openTime <= 6 && closeTime > 6 && closeTime <= 12);

            if (isOpenInSlot) {
                morningOpenRestaurants.add(restaurant);
            }
        }

        // Update your RecyclerView adapter with the filtered list
        yourRestaurantAdapter.submitList(morningOpenRestaurants);
    }

    @Override
    public void onCancelled(DatabaseError databaseError) {
        Log.e("Firebase", "Failed to fetch restaurants", databaseError.toException());
    }
});

Pros: No database schema changes, quick to implement.
Cons: Wastes bandwidth if you have a huge dataset, since you’re fetching more data than needed.

2. Add a Computed Field (Best for Large Datasets) #

For larger datasets, we can precompute a boolean field that flags whether a restaurant is open during your target slot. This lets you query directly on that field, avoiding client-side filtering overhead.

How it works: #

1. Add a new field (e.g., is_open_morning) to each restaurant node.
2. Set this field to true if the restaurant meets your 6–12 PM criteria, false otherwise.
3. Create a Firebase index for this field (required for efficient queries).

Step 1: Update Your Schema #

Each restaurant node will look like this:

{
  "name": "Joe's Diner",
  "open": 5,
  "close": 13,
  "is_open_morning": true
}

Step 2: Query the Computed Field #

// Query only restaurants where is_open_morning is true
restaurantRef.orderByChild("is_open_morning").equalTo(true)
    .addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            List<Restaurant> morningOpenRestaurants = new ArrayList<>();
            for (DataSnapshot snap : dataSnapshot.getChildren()) {
                morningOpenRestaurants.add(snap.getValue(Restaurant.class));
            }
            yourRestaurantAdapter.submitList(morningOpenRestaurants);
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
            Log.e("Firebase", "Query failed", databaseError.toException());
        }
    });

Step 3: Maintain the Field #

• When creating/updating a restaurant, calculate is_open_morning on the client before saving.
• For existing data, use a batch update or Firebase Cloud Functions to automatically set the field whenever open or close changes.

Pros: Efficient queries, minimal bandwidth usage.
Cons: Requires schema changes and ongoing maintenance of the computed field.

3. Migrate to Firestore (Most Flexible Long-Term) #

If you’re open to switching databases, Firebase Firestore natively supports multi-field AND queries. This eliminates all the workarounds and lets you filter directly on open and close times.

Code Example (Java): #

FirebaseFirestore db = FirebaseFirestore.getInstance();

db.collection("restaurants")
    .whereLessThanOrEqualTo("open", 6)
    .whereGreaterThanOrEqualTo("close", 12)
    .get()
    .addOnCompleteListener(task -> {
        if (task.isSuccessful()) {
            List<Restaurant> morningOpenRestaurants = new ArrayList<>();
            for (QueryDocumentSnapshot doc : task.getResult()) {
                morningOpenRestaurants.add(doc.toObject(Restaurant.class));
            }
            yourRestaurantAdapter.submitList(morningOpenRestaurants);
        } else {
            Log.e("Firestore", "Failed to fetch restaurants", task.getException());
        }
    });

Pros: Native multi-field query support, better scalability for complex queries.
Cons: Requires migrating your data and adjusting your codebase to Firestore’s API.

Final Recommendations #

• Use client-side filtering if your dataset is small and you want a quick fix.
• Use a computed field if you need efficient queries and want to stick with Realtime Database.
• Migrate to Firestore if you anticipate more complex filtering needs down the line.

内容的提问来源于stack exchange，提问作者Falcons